Merge remote branch 'rails/master'

27 files changed, 306 insertions, 101 deletions

diff --git a/activerecord/test/cases/connection_test_firebird.rb b/activerecord/test/cases/adapters/firebird/connection_test.rb
index f57ea686a5..f57ea686a5 100644
--- a/activerecord/test/cases/connection_test_firebird.rb
+++ b/activerecord/test/cases/adapters/firebird/connection_test.rb
diff --git a/activerecord/test/cases/default_test_firebird.rb b/activerecord/test/cases/adapters/firebird/default_test.rb
index 713c7e11bf..713c7e11bf 100644
--- a/activerecord/test/cases/default_test_firebird.rb
+++ b/activerecord/test/cases/adapters/firebird/default_test.rb
diff --git a/activerecord/test/cases/migration_test_firebird.rb b/activerecord/test/cases/adapters/firebird/migration_test.rb
index 710661b9bd..710661b9bd 100644
--- a/activerecord/test/cases/migration_test_firebird.rb
+++ b/activerecord/test/cases/adapters/firebird/migration_test.rb
diff --git a/activerecord/test/cases/active_schema_test_mysql.rb b/activerecord/test/cases/adapters/mysql/active_schema_test.rb
index d7431e5158..6e6645511c 100644
--- a/activerecord/test/cases/active_schema_test_mysql.rb
+++ b/activerecord/test/cases/adapters/mysql/active_schema_test.rb
@@ -17,8 +17,8 @@ class ActiveSchemaTest < ActiveRecord::TestCase
   end
 
   def test_add_index
-    # add_index calls index_exists? which can't work since execute is stubbed
-    ActiveRecord::ConnectionAdapters::MysqlAdapter.send(:define_method, :index_exists?) do |*|
+    # add_index calls index_name_exists? which can't work since execute is stubbed
+    ActiveRecord::ConnectionAdapters::MysqlAdapter.send(:define_method, :index_name_exists?) do |*|
       false
     end
     expected = "CREATE  INDEX `index_people_on_last_name` ON `people` (`last_name`)"
@@ -35,7 +35,7 @@ class ActiveSchemaTest < ActiveRecord::TestCase
 
     expected = "CREATE  INDEX `index_people_on_last_name_and_first_name` ON `people` (`last_name`(15), `first_name`(10))"
     assert_equal expected, add_index(:people, [:last_name, :first_name], :length => {:last_name => 15, :first_name => 10})
-    ActiveRecord::ConnectionAdapters::MysqlAdapter.send(:remove_method, :index_exists?)
+    ActiveRecord::ConnectionAdapters::MysqlAdapter.send(:remove_method, :index_name_exists?)
   end
 
   def test_drop_table
diff --git a/activerecord/test/cases/connection_test_mysql.rb b/activerecord/test/cases/adapters/mysql/connection_test.rb
index 8e4842a1b6..8e4842a1b6 100644
--- a/activerecord/test/cases/connection_test_mysql.rb
+++ b/activerecord/test/cases/adapters/mysql/connection_test.rb
diff --git a/activerecord/test/cases/reserved_word_test_mysql.rb b/activerecord/test/cases/adapters/mysql/reserved_word_test.rb
index 90d8b0d923..90d8b0d923 100644
--- a/activerecord/test/cases/reserved_word_test_mysql.rb
+++ b/activerecord/test/cases/adapters/mysql/reserved_word_test.rb
diff --git a/activerecord/test/cases/synonym_test_oracle.rb b/activerecord/test/cases/adapters/oracle/synonym_test.rb
index b9a422a6ca..b9a422a6ca 100644
--- a/activerecord/test/cases/synonym_test_oracle.rb
+++ b/activerecord/test/cases/adapters/oracle/synonym_test.rb
diff --git a/activerecord/test/cases/active_schema_test_postgresql.rb b/activerecord/test/cases/adapters/postgresql/active_schema_test.rb
index 4f04c6735c..f106e14319 100644
--- a/activerecord/test/cases/active_schema_test_postgresql.rb
+++ b/activerecord/test/cases/adapters/postgresql/active_schema_test.rb
@@ -10,7 +10,10 @@ class PostgresqlActiveSchemaTest < Test::Unit::TestCase
   end
 
   def teardown
-    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.send(:alias_method, :execute, :real_execute)
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.class_eval do
+      remove_method :execute
+      alias_method :execute, :real_execute
+    end
   end
 
   def test_create_database_with_encoding
diff --git a/activerecord/test/cases/datatype_test_postgresql.rb b/activerecord/test/cases/adapters/postgresql/datatype_test.rb
index 3c2d9fb7bd..5bb8fa2f93 100644
--- a/activerecord/test/cases/datatype_test_postgresql.rb
+++ b/activerecord/test/cases/adapters/postgresql/datatype_test.rb
@@ -53,7 +53,7 @@ class PostgresqlDataTypeTest < ActiveRecord::TestCase
 
     @connection.execute("INSERT INTO postgresql_oids (obj_id) VALUES (1234)")
     @first_oid = PostgresqlOid.find(1)
-    
+
     @connection.execute("INSERT INTO postgresql_timestamp_with_zones (time) VALUES ('2010-01-01 10:00:00-1')")
   end
 
diff --git a/activerecord/test/cases/schema_authorization_test_postgresql.rb b/activerecord/test/cases/adapters/postgresql/schema_authorization_test.rb
index 2860f1ad48..6f372edc38 100644
--- a/activerecord/test/cases/schema_authorization_test_postgresql.rb
+++ b/activerecord/test/cases/adapters/postgresql/schema_authorization_test.rb
@@ -66,7 +66,7 @@ class SchemaAuthorizationTest < ActiveRecord::TestCase
       end
     end
   end
-  
+
   def test_tables_in_current_schemas
     assert !@connection.tables.include?(TABLE_NAME)
     USERS.each do |u|
diff --git a/activerecord/test/cases/schema_test_postgresql.rb b/activerecord/test/cases/adapters/postgresql/schema_test.rb
index 3ed9b1974d..a5c3e69af9 100644
--- a/activerecord/test/cases/schema_test_postgresql.rb
+++ b/activerecord/test/cases/adapters/postgresql/schema_test.rb
@@ -9,9 +9,11 @@ class SchemaTest < ActiveRecord::TestCase
   CAPITALIZED_TABLE_NAME = 'Things'
   INDEX_A_NAME = 'a_index_things_on_name'
   INDEX_B_NAME = 'b_index_things_on_different_columns_in_each_schema'
+  INDEX_C_NAME = 'c_index_full_text_search'
   INDEX_A_COLUMN = 'name'
   INDEX_B_COLUMN_S1 = 'email'
   INDEX_B_COLUMN_S2 = 'moment'
+  INDEX_C_COLUMN = %q{(to_tsvector('english', coalesce(things.name, '')))}
   COLUMNS = [
     'id integer',
     'name character varying(50)',
@@ -45,6 +47,8 @@ class SchemaTest < ActiveRecord::TestCase
     @connection.execute "CREATE INDEX #{INDEX_A_NAME} ON #{SCHEMA2_NAME}.#{TABLE_NAME}  USING btree (#{INDEX_A_COLUMN});"
     @connection.execute "CREATE INDEX #{INDEX_B_NAME} ON #{SCHEMA_NAME}.#{TABLE_NAME}  USING btree (#{INDEX_B_COLUMN_S1});"
     @connection.execute "CREATE INDEX #{INDEX_B_NAME} ON #{SCHEMA2_NAME}.#{TABLE_NAME}  USING btree (#{INDEX_B_COLUMN_S2});"
+    @connection.execute "CREATE INDEX #{INDEX_C_NAME} ON #{SCHEMA_NAME}.#{TABLE_NAME}  USING gin (#{INDEX_C_COLUMN});"
+    @connection.execute "CREATE INDEX #{INDEX_C_NAME} ON #{SCHEMA2_NAME}.#{TABLE_NAME}  USING gin (#{INDEX_C_COLUMN});"
   end
 
   def teardown
diff --git a/activerecord/test/cases/copy_table_test_sqlite.rb b/activerecord/test/cases/adapters/sqlite/copy_table_test.rb
index 575b4806c1..575b4806c1 100644
--- a/activerecord/test/cases/copy_table_test_sqlite.rb
+++ b/activerecord/test/cases/adapters/sqlite/copy_table_test.rb
diff --git a/activerecord/test/cases/adapters/sqlite/sqlite3_adapter_test.rb b/activerecord/test/cases/adapters/sqlite/sqlite3_adapter_test.rb
new file mode 100644
index 0000000000..934cf72f72
--- /dev/null
+++ b/activerecord/test/cases/adapters/sqlite/sqlite3_adapter_test.rb
@@ -0,0 +1,56 @@
+require "cases/helper"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class SQLite3AdapterTest < ActiveRecord::TestCase
+      def test_connection_no_db
+        assert_raises(ArgumentError) do
+          Base.sqlite3_connection {}
+        end
+      end
+
+      def test_connection_no_adapter
+        assert_raises(ArgumentError) do
+          Base.sqlite3_connection :database => ':memory:'
+        end
+      end
+
+      def test_connection_wrong_adapter
+        assert_raises(ArgumentError) do
+          Base.sqlite3_connection :database => ':memory:',:adapter => 'vuvuzela'
+        end
+      end
+
+      def test_bad_timeout
+        assert_raises(TypeError) do
+          Base.sqlite3_connection :database => ':memory:',
+                                  :adapter => 'sqlite3',
+                                  :timeout => 'usa'
+        end
+      end
+
+      # connection is OK with a nil timeout
+      def test_nil_timeout
+        conn = Base.sqlite3_connection :database => ':memory:',
+                                       :adapter => 'sqlite3',
+                                       :timeout => nil
+        assert conn, 'made a connection'
+      end
+
+      def test_connect
+        conn = Base.sqlite3_connection :database => ':memory:',
+                                       :adapter => 'sqlite3',
+                                       :timeout => 100
+        assert conn, 'should have connection'
+      end
+
+      # sqlite3 defaults to UTF-8 encoding
+      def test_encoding
+        conn = Base.sqlite3_connection :database => ':memory:',
+                                       :adapter => 'sqlite3',
+                                       :timeout => 100
+        assert_equal 'UTF-8', conn.encoding
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/aggregations_test.rb b/activerecord/test/cases/aggregations_test.rb
index e5fc1a2046..74588b4f47 100644
--- a/activerecord/test/cases/aggregations_test.rb
+++ b/activerecord/test/cases/aggregations_test.rb
@@ -121,34 +121,6 @@ class AggregationsTest < ActiveRecord::TestCase
   end
 end
 
-class DeprecatedAggregationsTest < ActiveRecord::TestCase
-  class Person < ActiveRecord::Base; end
-
-  def test_conversion_block_is_deprecated
-    assert_deprecated 'conversion block has been deprecated' do
-      Person.composed_of(:balance, :class_name => "Money", :mapping => %w(balance amount)) { |balance| balance.to_money }
-    end
-  end
-
-  def test_conversion_block_used_when_converter_option_is_nil
-    assert_deprecated 'conversion block has been deprecated' do
-      Person.composed_of(:balance, :class_name => "Money", :mapping => %w(balance amount)) { |balance| balance.to_money }
-    end
-    assert_raise(NoMethodError) { Person.new.balance = 5 }
-  end
-
-  def test_converter_option_overrides_conversion_block
-    assert_deprecated 'conversion block has been deprecated' do
-      Person.composed_of(:balance, :class_name => "Money", :mapping => %w(balance amount), :converter => Proc.new { |balance| Money.new(balance) }) { |balance| balance.to_money }
-    end
-
-    person = Person.new
-    assert_nothing_raised { person.balance = 5 }
-    assert_equal 5, person.balance.amount
-    assert_kind_of Money, person.balance
-  end
-end
-
 class OverridingAggregationsTest < ActiveRecord::TestCase
   class Name; end
   class DifferentName; end
diff --git a/activerecord/test/cases/associations/cascaded_eager_loading_test.rb b/activerecord/test/cases/associations/cascaded_eager_loading_test.rb
index 050b730dda..9c5dcc2ad9 100644
--- a/activerecord/test/cases/associations/cascaded_eager_loading_test.rb
+++ b/activerecord/test/cases/associations/cascaded_eager_loading_test.rb
@@ -41,9 +41,9 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
 
   def test_eager_association_loading_grafts_stashed_associations_to_correct_parent
     assert_nothing_raised do
-      Person.eager_load(:primary_contact => :primary_contact).where('primary_contacts_people_2.first_name = ?', 'Susan').order('primary_contacts_people_2.id').all
+      Person.eager_load(:primary_contact => :primary_contact).where('primary_contacts_people_2.first_name = ?', 'Susan').order('people.id').all
     end
-    assert_equal people(:michael), Person.eager_load(:primary_contact => :primary_contact).where('primary_contacts_people_2.first_name = ?', 'Susan').order('primary_contacts_people_2.id').first
+    assert_equal people(:michael), Person.eager_load(:primary_contact => :primary_contact).where('primary_contacts_people_2.first_name = ?', 'Susan').order('people.id').first
   end
 
   def test_eager_association_loading_with_cascaded_two_levels_with_two_has_many_associations
diff --git a/activerecord/test/cases/base_test.rb b/activerecord/test/cases/base_test.rb
index 7c74d87b61..f8b90d8877 100644
--- a/activerecord/test/cases/base_test.rb
+++ b/activerecord/test/cases/base_test.rb
@@ -1401,6 +1401,14 @@ class BasicsTest < ActiveRecord::TestCase
     assert_not_equal clone.id, dev.id
   end
 
+  def test_clone_does_not_clone_associations
+    author = authors(:david)
+    assert_not_equal [], author.posts
+
+    author_clone = author.clone
+    assert_equal [], author_clone.posts
+  end
+
   def test_clone_preserves_subtype
     clone = nil
     assert_nothing_raised { clone = Company.find(3).clone }
@@ -2235,7 +2243,7 @@ class BasicsTest < ActiveRecord::TestCase
 
   def test_inspect_instance
     topic = topics(:first)
-    assert_equal %(#<Topic id: 1, title: "The First Topic", author_name: "David", author_email_address: "david@loudthinking.com", written_on: "#{topic.written_on.to_s(:db)}", bonus_time: "#{topic.bonus_time.to_s(:db)}", last_read: "#{topic.last_read.to_s(:db)}", content: "Have a nice day", approved: false, replies_count: 1, parent_id: nil, parent_title: nil, type: nil>), topic.inspect
+    assert_equal %(#<Topic id: 1, title: "The First Topic", author_name: "David", author_email_address: "david@loudthinking.com", written_on: "#{topic.written_on.to_s(:db)}", bonus_time: "#{topic.bonus_time.to_s(:db)}", last_read: "#{topic.last_read.to_s(:db)}", content: "Have a nice day", approved: false, replies_count: 1, parent_id: nil, parent_title: nil, type: nil, group: nil>), topic.inspect
   end
 
   def test_inspect_new_instance
diff --git a/activerecord/test/cases/calculations_test.rb b/activerecord/test/cases/calculations_test.rb
index 329dd7d761..2c9d23c80f 100644
--- a/activerecord/test/cases/calculations_test.rb
+++ b/activerecord/test/cases/calculations_test.rb
@@ -272,7 +272,7 @@ class CalculationsTest < ActiveRecord::TestCase
   end
 
   def test_count_with_column_and_options_parameter
-    assert_equal 2, Account.count(:firm_id, :conditions => "credit_limit = 50")
+    assert_equal 2, Account.count(:firm_id, :conditions => "credit_limit = 50 AND firm_id IS NOT NULL")
   end
 
   def test_count_with_no_parameters_isnt_deprecated
diff --git a/activerecord/test/cases/log_subscriber_test.rb b/activerecord/test/cases/log_subscriber_test.rb
index 1f544b4211..4aeae1fe45 100644
--- a/activerecord/test/cases/log_subscriber_test.rb
+++ b/activerecord/test/cases/log_subscriber_test.rb
@@ -1,20 +1,19 @@
 require "cases/helper"
 require "models/developer"
-require "rails/log_subscriber/test_helper"
-require "active_record/railties/log_subscriber"
+require "active_support/log_subscriber/test_helper"
 
 class LogSubscriberTest < ActiveSupport::TestCase
-  include Rails::LogSubscriber::TestHelper
+  include ActiveSupport::LogSubscriber::TestHelper
 
   def setup
     @old_logger = ActiveRecord::Base.logger
     super
-
-    Rails::LogSubscriber.add(:active_record, ActiveRecord::Railties::LogSubscriber.new)
+    ActiveRecord::LogSubscriber.attach_to(:active_record)
   end
 
   def teardown
     super
+    ActiveRecord::LogSubscriber.log_subscribers.pop
     ActiveRecord::Base.logger = @old_logger
   end
 
diff --git a/activerecord/test/cases/method_scoping_test.rb b/activerecord/test/cases/method_scoping_test.rb
index e93f22bede..6cd42ff936 100644
--- a/activerecord/test/cases/method_scoping_test.rb
+++ b/activerecord/test/cases/method_scoping_test.rb
@@ -77,11 +77,13 @@ class MethodScopingTest < ActiveRecord::TestCase
     end
   end
 
-  def test_options_select_replaces_scope_select
-    Developer.send(:with_scope, :find => { :select => "id, name" }) do
+  def test_scope_select_concatenates
+    Developer.send(:with_scope, :find => { :select => "name" }) do
       developer = Developer.find(:first, :select => 'id, salary', :conditions => "name = 'David'")
       assert_equal 80000, developer.salary
-      assert !developer.has_attribute?(:name)
+      assert developer.has_attribute?(:id)
+      assert developer.has_attribute?(:name)
+      assert developer.has_attribute?(:salary)
     end
   end
 
diff --git a/activerecord/test/cases/migration_test.rb b/activerecord/test/cases/migration_test.rb
index 6fe3b01281..99a3a12a8b 100644
--- a/activerecord/test/cases/migration_test.rb
+++ b/activerecord/test/cases/migration_test.rb
@@ -128,9 +128,9 @@ if ActiveRecord::Base.connection.supports_migrations?
       good_index_name = 'x' * Person.connection.index_name_length
       too_long_index_name = good_index_name + 'x'
       assert_nothing_raised { Person.connection.add_index("people", "first_name", :name => too_long_index_name) }
-      assert !Person.connection.index_exists?("people", too_long_index_name, false)
+      assert !Person.connection.index_name_exists?("people", too_long_index_name, false)
       assert_nothing_raised { Person.connection.add_index("people", "first_name", :name => good_index_name) }
-      assert Person.connection.index_exists?("people", good_index_name, false)
+      assert Person.connection.index_name_exists?("people", good_index_name, false)
     end
 
     def test_remove_nonexistent_index
@@ -146,8 +146,8 @@ if ActiveRecord::Base.connection.supports_migrations?
         Person.connection.add_index('people', [:first_name], :name => 'old_idx')
         assert_nothing_raised { Person.connection.rename_index('people', 'old_idx', 'new_idx') }
         # if the adapter doesn't support the indexes call, pick defaults that let the test pass
-        assert !Person.connection.index_exists?('people', 'old_idx', false)
-        assert Person.connection.index_exists?('people', 'new_idx', true)
+        assert !Person.connection.index_name_exists?('people', 'old_idx', false)
+        assert Person.connection.index_name_exists?('people', 'new_idx', true)
       end
     end
 
@@ -158,6 +158,53 @@ if ActiveRecord::Base.connection.supports_migrations?
       end
     end
 
+    def test_index_exists
+      Person.connection.create_table :testings do |t|
+        t.column :foo, :string, :limit => 100
+        t.column :bar, :string, :limit => 100
+      end
+      Person.connection.add_index :testings, :foo
+
+      assert Person.connection.index_exists?(:testings, :foo)
+      assert !Person.connection.index_exists?(:testings, :bar)
+    ensure
+      Person.connection.drop_table :testings rescue nil
+    end
+
+    def test_index_exists_on_multiple_columns
+      Person.connection.create_table :testings do |t|
+        t.column :foo, :string, :limit => 100
+        t.column :bar, :string, :limit => 100
+      end
+      Person.connection.add_index :testings, [:foo, :bar]
+
+      assert Person.connection.index_exists?(:testings, [:foo, :bar])
+    ensure
+      Person.connection.drop_table :testings rescue nil
+    end
+
+    def test_unique_index_exists
+      Person.connection.create_table :testings do |t|
+        t.column :foo, :string, :limit => 100
+      end
+      Person.connection.add_index :testings, :foo, :unique => true
+
+      assert Person.connection.index_exists?(:testings, :foo, :unique => true)
+    ensure
+      Person.connection.drop_table :testings rescue nil
+    end
+
+    def test_named_index_exists
+      Person.connection.create_table :testings do |t|
+        t.column :foo, :string, :limit => 100
+      end
+      Person.connection.add_index :testings, :foo, :name => "custom_index_name"
+
+      assert Person.connection.index_exists?(:testings, :foo, :name => "custom_index_name")
+    ensure
+      Person.connection.drop_table :testings rescue nil
+    end
+
     def testing_table_with_only_foo_attribute
       Person.connection.create_table :testings, :id => false do |t|
         t.column :foo, :string
@@ -748,6 +795,10 @@ if ActiveRecord::Base.connection.supports_migrations?
       ActiveRecord::Base.connection.drop_table(:hats)
     end
 
+    def test_remove_column_no_second_parameter_raises_exception
+      assert_raise(ArgumentError) { Person.connection.remove_column("funny") }
+    end
+
     def test_change_type_of_not_null_column
       assert_nothing_raised do
         Topic.connection.change_column "topics", "written_on", :datetime, :null => false
@@ -970,6 +1021,45 @@ if ActiveRecord::Base.connection.supports_migrations?
       assert_nil Person.new.first_name
     end
 
+    def test_column_exists
+      Person.connection.create_table :testings do |t|
+        t.column :foo, :string
+      end
+
+      assert Person.connection.column_exists?(:testings, :foo)
+      assert !Person.connection.column_exists?(:testings, :bar)
+    ensure
+      Person.connection.drop_table :testings rescue nil
+    end
+
+    def test_column_exists_with_type
+      Person.connection.create_table :testings do |t|
+        t.column :foo, :string
+        t.column :bar, :decimal, :precision => 8, :scale => 2
+      end
+
+      assert Person.connection.column_exists?(:testings, :foo, :string)
+      assert !Person.connection.column_exists?(:testings, :foo, :integer)
+      assert Person.connection.column_exists?(:testings, :bar, :decimal)
+      assert !Person.connection.column_exists?(:testings, :bar, :integer)
+    ensure
+      Person.connection.drop_table :testings rescue nil
+    end
+
+    def test_column_exists_with_definition
+      Person.connection.create_table :testings do |t|
+        t.column :foo, :string, :limit => 100
+        t.column :bar, :decimal, :precision => 8, :scale => 2
+      end
+
+      assert Person.connection.column_exists?(:testings, :foo, :string, :limit => 100)
+      assert !Person.connection.column_exists?(:testings, :foo, :string, :limit => 50)
+      assert Person.connection.column_exists?(:testings, :bar, :decimal, :precision => 8, :scale => 2)
+      assert !Person.connection.column_exists?(:testings, :bar, :decimal, :precision => 10, :scale => 2)
+    ensure
+      Person.connection.drop_table :testings rescue nil
+    end
+
     def test_add_table
       assert !Reminder.table_exists?
 
@@ -1680,6 +1770,20 @@ if ActiveRecord::Base.connection.supports_migrations?
       end
     end
 
+    def test_index_exists
+      with_change_table do |t|
+        @connection.expects(:index_exists?).with(:delete_me, :bar, {})
+        t.index_exists?(:bar)
+      end
+    end
+
+    def test_index_exists_with_options
+      with_change_table do |t|
+        @connection.expects(:index_exists?).with(:delete_me, :bar, {:unique => true})
+        t.index_exists?(:bar, :unique => true)
+      end
+    end
+
     def test_change_changes_column
       with_change_table do |t|
         @connection.expects(:change_column).with(:delete_me, :bar, :string, {})
diff --git a/activerecord/test/cases/nested_attributes_test.rb b/activerecord/test/cases/nested_attributes_test.rb
index 65d6080ea5..3c797076e0 100644
--- a/activerecord/test/cases/nested_attributes_test.rb
+++ b/activerecord/test/cases/nested_attributes_test.rb
@@ -176,12 +176,6 @@ class TestNestedAttributesOnAHasOneAssociation < ActiveRecord::TestCase
     assert_equal 'Davy Jones Gold Dagger', @pirate.ship.name
   end
 
-  def test_should_raise_RecordNotFound_if_an_id_is_given_but_doesnt_return_a_record
-    assert_raise_with_message ActiveRecord::RecordNotFound, "Couldn't find Ship with ID=1234567890 for Pirate with ID=#{@pirate.id}" do
-      @pirate.ship_attributes = { :id => 1234567890 }
-    end
-  end
-
   def test_should_take_a_hash_with_string_keys_and_update_the_associated_model
     @pirate.reload.ship_attributes = { 'id' => @ship.id, 'name' => 'Davy Jones Gold Dagger' }
 
@@ -331,11 +325,14 @@ class TestNestedAttributesOnABelongsToAssociation < ActiveRecord::TestCase
     assert_equal 'Arr', @ship.pirate.catchphrase
   end
 
-  def test_should_raise_RecordNotFound_if_an_id_is_given_but_doesnt_return_a_record
-    assert_raise_with_message ActiveRecord::RecordNotFound, "Couldn't find Pirate with ID=1234567890 for Ship with ID=#{@ship.id}" do
-      @ship.pirate_attributes = { :id => 1234567890 }
-    end
-  end
+  def test_should_associate_with_record_if_parent_record_is_not_saved
+    @ship.destroy
+    @pirate = Pirate.create(:catchphrase => 'Arr')
+    @ship = Ship.new(:name => 'Nights Dirty Lightning', :pirate_attributes => { :id => @pirate.id, :catchphrase => @pirate.catchphrase})
+
+    assert_equal @ship.name, 'Nights Dirty Lightning'
+    assert_equal @pirate, @ship.pirate
+   end
 
   def test_should_take_a_hash_with_string_keys_and_update_the_associated_model
     @ship.reload.pirate_attributes = { 'id' => @pirate.id, 'catchphrase' => 'Arr' }
@@ -444,6 +441,11 @@ module NestedAttributesOnACollectionAssociationTests
     assert_equal ['Grace OMalley', 'Privateers Greed'], [@child_1.reload.name, @child_2.reload.name]
   end
 
+  def test_should_assign_existing_children_if_parent_is_new
+    @pirate = Pirate.new({:catchphrase => "Don' botharr talkin' like one, savvy?"}.merge(@alternate_params))
+    assert_equal ['Grace OMalley', 'Privateers Greed'], [@pirate.send(@association_name)[0].name, @pirate.send(@association_name)[1].name]
+  end
+
   def test_should_also_work_with_a_HashWithIndifferentAccess
     @pirate.send(association_setter, HashWithIndifferentAccess.new('foo' => HashWithIndifferentAccess.new(:id => @child_1.id, :name => 'Grace OMalley')))
     @pirate.save
@@ -501,8 +503,8 @@ module NestedAttributesOnACollectionAssociationTests
     assert_equal ['Grace OMalley', 'Privateers Greed'], [@child_1.name, @child_2.name]
   end
 
-  def test_should_raise_RecordNotFound_if_an_id_is_given_but_doesnt_return_a_record
-    assert_raise_with_message ActiveRecord::RecordNotFound, "Couldn't find #{@child_1.class.name} with ID=1234567890 for Pirate with ID=#{@pirate.id}" do
+  def test_should_not_raise_RecordNotFound_if_an_id_is_given_but_doesnt_return_a_record
+    assert_nothing_raised ActiveRecord::RecordNotFound do
       @pirate.attributes = { association_getter => [{ :id => 1234567890 }] }
     end
   end
diff --git a/activerecord/test/cases/reflection_test.rb b/activerecord/test/cases/reflection_test.rb
index 67818622d7..03c4fc4e80 100644
--- a/activerecord/test/cases/reflection_test.rb
+++ b/activerecord/test/cases/reflection_test.rb
@@ -24,25 +24,25 @@ class ReflectionTest < ActiveRecord::TestCase
 
   def test_read_attribute_names
     assert_equal(
-      %w( id title author_name author_email_address bonus_time written_on last_read content approved replies_count parent_id parent_title type ).sort,
+      %w( id title author_name author_email_address bonus_time written_on last_read content group approved replies_count parent_id parent_title type ).sort,
       @first.attribute_names
     )
   end
 
   def test_columns
-    assert_equal 13, Topic.columns.length
+    assert_equal 14, Topic.columns.length
   end
 
   def test_columns_are_returned_in_the_order_they_were_declared
     column_names = Topic.columns.map { |column| column.name }
-    assert_equal %w(id title author_name author_email_address written_on bonus_time last_read content approved replies_count parent_id parent_title type), column_names
+    assert_equal %w(id title author_name author_email_address written_on bonus_time last_read content approved replies_count parent_id parent_title type group), column_names
   end
 
   def test_content_columns
     content_columns        = Topic.content_columns
     content_column_names   = content_columns.map {|column| column.name}
-    assert_equal 9, content_columns.length
-    assert_equal %w(title author_name author_email_address written_on bonus_time last_read content approved parent_title).sort, content_column_names.sort
+    assert_equal 10, content_columns.length
+    assert_equal %w(title author_name author_email_address written_on bonus_time last_read content group approved parent_title).sort, content_column_names.sort
   end
 
   def test_column_string_type_and_limit
diff --git a/activerecord/test/cases/relations_test.rb b/activerecord/test/cases/relations_test.rb
index 43519db976..d27a69ea1c 100644
--- a/activerecord/test/cases/relations_test.rb
+++ b/activerecord/test/cases/relations_test.rb
@@ -16,12 +16,34 @@ class RelationTest < ActiveRecord::TestCase
   fixtures :authors, :topics, :entrants, :developers, :companies, :developers_projects, :accounts, :categories, :categorizations, :posts, :comments,
     :taggings
 
+  def test_apply_relation_as_where_id
+    posts = Post.arel_table
+    post_authors = posts.where(posts[:author_id].eq(1)).project(posts[:id])
+    assert_equal 5, post_authors.to_a.size
+    assert_equal 5, Post.where(:id => post_authors).size
+  end
+
   def test_scoped
     topics = Topic.scoped
     assert_kind_of ActiveRecord::Relation, topics
     assert_equal 4, topics.size
   end
 
+  def test_to_json
+    assert_nothing_raised  { Bird.scoped.to_json }
+    assert_nothing_raised  { Bird.scoped.all.to_json }
+  end
+
+  def test_to_yaml
+    assert_nothing_raised  { Bird.scoped.to_yaml }
+    assert_nothing_raised  { Bird.scoped.all.to_yaml }
+  end
+
+  def test_to_xml
+    assert_nothing_raised  { Bird.scoped.to_xml }
+    assert_nothing_raised  { Bird.scoped.all.to_xml }
+  end
+
   def test_scoped_all
     topics = Topic.scoped.all
     assert_kind_of Array, topics
@@ -88,6 +110,18 @@ class RelationTest < ActiveRecord::TestCase
     assert_equal topics(:first).title, topics.first.title
   end
 
+  def test_finding_with_order_concatenated
+    topics = Topic.order('author_name').order('title')
+    assert_equal 4, topics.to_a.size
+    assert_equal topics(:fourth).title, topics.first.title
+  end
+
+  def test_finding_with_reorder
+    topics = Topic.order('author_name').order('title').reorder('id')
+    assert_equal 4, topics.to_a.size
+    assert_equal topics(:first).title, topics.first.title
+  end
+
   def test_finding_with_order_and_take
     entrants = Entrant.order("id ASC").limit(2).to_a
 
@@ -461,7 +495,7 @@ class RelationTest < ActiveRecord::TestCase
     posts = Post.scoped
 
     assert_equal [0], posts.select('comments_count').where('id is not null').group('id').order('id').count.values.uniq
-    assert_equal 0, posts.where('id is not null').select('comments_count').count
+    assert_equal 7, posts.where('id is not null').select('comments_count').count
 
     assert_equal 7, posts.select('comments_count').count('id')
     assert_equal 0, posts.select('comments_count').count
@@ -469,6 +503,12 @@ class RelationTest < ActiveRecord::TestCase
     assert_equal 0, posts.count('comments_count')
   end
 
+  def test_multiple_selects
+    post = Post.scoped.select('comments_count').select('title').order("id ASC").first
+    assert_equal "Welcome to the weblog", post.title
+    assert_equal 2, post.comments_count
+  end
+
   def test_size
     posts = Post.scoped
 
@@ -503,13 +543,13 @@ class RelationTest < ActiveRecord::TestCase
 
   def test_many
     posts = Post.scoped
-  
+
     assert_queries(2) do
       assert posts.many? # Uses COUNT()
       assert posts.many? {|p| p.id > 0 }
       assert ! posts.many? {|p| p.id < 2 }
     end
-  
+
     assert posts.loaded?
   end
 
@@ -578,7 +618,7 @@ class RelationTest < ActiveRecord::TestCase
   end
 
   def test_anonymous_extension
-    relation = Post.where(:author_id => 1).order('id ASC') do
+    relation = Post.where(:author_id => 1).order('id ASC').extend do
       def author
         'lifo'
       end
@@ -593,4 +633,12 @@ class RelationTest < ActiveRecord::TestCase
     assert_equal "lifo", relation.author
     assert_equal "lifo", relation.limit(1).author
   end
+
+  def test_order_by_relation_attribute
+    assert_equal Post.order(Post.arel_table[:title]).all, Post.order("title").all
+  end
+
+  def test_relations_limit_with_conditions_or_limit
+    assert_equal Post.limit(2).size, Post.limit(2).all.size
+  end
 end
diff --git a/activerecord/test/cases/validations/i18n_generate_message_validation_test.rb b/activerecord/test/cases/validations/i18n_generate_message_validation_test.rb
index 8ee2a5868c..454e42ed37 100644
--- a/activerecord/test/cases/validations/i18n_generate_message_validation_test.rb
+++ b/activerecord/test/cases/validations/i18n_generate_message_validation_test.rb
@@ -9,22 +9,22 @@ class I18nGenerateMessageValidationTest < ActiveRecord::TestCase
     I18n.backend = I18n::Backend::Simple.new
   end
 
-  # validates_associated: generate_message(attr_name, :invalid, :default => configuration[:message], :value => value)
+  # validates_associated: generate_message(attr_name, :invalid, :message => custom_message, :value => value)
   def test_generate_message_invalid_with_default_message
-    assert_equal 'is invalid', @topic.errors.generate_message(:title, :invalid, :default => nil, :value => 'title')
+    assert_equal 'is invalid', @topic.errors.generate_message(:title, :invalid, :value => 'title')
   end
 
   def test_generate_message_invalid_with_custom_message
-    assert_equal 'custom message title', @topic.errors.generate_message(:title, :invalid, :default => 'custom message %{value}', :value => 'title')
+    assert_equal 'custom message title', @topic.errors.generate_message(:title, :invalid, :message => 'custom message %{value}', :value => 'title')
   end
 
-  # validates_uniqueness_of: generate_message(attr_name, :taken, :default => configuration[:message])
+  # validates_uniqueness_of: generate_message(attr_name, :taken, :message => custom_message)
   def test_generate_message_taken_with_default_message
-    assert_equal "has already been taken", @topic.errors.generate_message(:title, :taken, :default => nil, :value => 'title')
+    assert_equal "has already been taken", @topic.errors.generate_message(:title, :taken, :value => 'title')
   end
 
   def test_generate_message_taken_with_custom_message
-    assert_equal 'custom message title', @topic.errors.generate_message(:title, :taken, :default => 'custom message %{value}', :value => 'title')
+    assert_equal 'custom message title', @topic.errors.generate_message(:title, :taken, :message => 'custom message %{value}', :value => 'title')
   end
 
   # ActiveRecord#RecordInvalid exception
diff --git a/activerecord/test/cases/validations/i18n_validation_test.rb b/activerecord/test/cases/validations/i18n_validation_test.rb
index 38fa2b821d..15b97c02c8 100644
--- a/activerecord/test/cases/validations/i18n_validation_test.rb
+++ b/activerecord/test/cases/validations/i18n_validation_test.rb
@@ -31,34 +31,40 @@ class I18nValidationTest < ActiveRecord::TestCase
     end
   end
 
-  # validates_uniqueness_of w/ mocha
+  # A set of common cases for ActiveModel::Validations message generation that
+  # are used to generate tests to keep things DRY
+  #
+  COMMON_CASES = [
+  # [ case,                                validation_options,            generate_message_options]
+    [ "given no options",                  {},                            {}],
+    [ "given custom message",              {:message => "custom"},        {:message => "custom"}],
+    [ "given if condition",                {:if     => lambda { true }},  {}],
+    [ "given unless condition",            {:unless => lambda { false }}, {}],
+    [ "given option that is not reserved", {:format => "jpg"},            {:format => "jpg" }]
+    # TODO Add :on case, but below doesn't work, because then the validation isn't run for some reason
+    #      even when using .save instead .valid?
+    # [ "given on condition",     {:on => :save},                {}]
+  ]
 
-  def test_validates_uniqueness_of_generates_message
-    Topic.validates_uniqueness_of :title
-    @topic.title = unique_topic.title
-    @topic.errors.expects(:generate_message).with(:title, :taken, {:default => nil, :value => 'unique!'})
-    @topic.valid?
-  end
+  # validates_uniqueness_of w/ mocha
 
-  def test_validates_uniqueness_of_generates_message_with_custom_default_message
-    Topic.validates_uniqueness_of :title, :message => 'custom'
-    @topic.title = unique_topic.title
-    @topic.errors.expects(:generate_message).with(:title, :taken, {:default => 'custom', :value => 'unique!'})
-    @topic.valid?
+  COMMON_CASES.each do |name, validation_options, generate_message_options|
+    test "validates_uniqueness_of on generated message #{name}" do
+      Topic.validates_uniqueness_of :title, validation_options
+      @topic.title = unique_topic.title
+      @topic.errors.expects(:generate_message).with(:title, :taken, generate_message_options.merge(:value => 'unique!'))
+      @topic.valid?
+    end
   end
 
   # validates_associated w/ mocha
 
-  def test_validates_associated_generates_message
-    Topic.validates_associated :replies
-    replied_topic.errors.expects(:generate_message).with(:replies, :invalid, {:value => replied_topic.replies, :default => nil})
-    replied_topic.valid?
-  end
-
-  def test_validates_associated_generates_message_with_custom_default_message
-    Topic.validates_associated :replies
-    replied_topic.errors.expects(:generate_message).with(:replies, :invalid, {:value => replied_topic.replies, :default => nil})
-    replied_topic.valid?
+  COMMON_CASES.each do |name, validation_options, generate_message_options|
+    test "validates_associated on generated message #{name}" do
+      Topic.validates_associated :replies, validation_options
+      replied_topic.errors.expects(:generate_message).with(:replies, :invalid, generate_message_options.merge(:value => replied_topic.replies))
+      replied_topic.save
+    end
   end
 
   # validates_associated w/o mocha
diff --git a/activerecord/test/fixtures/topics.yml b/activerecord/test/fixtures/topics.yml
index 1769152445..93f48aedc4 100644
--- a/activerecord/test/fixtures/topics.yml
+++ b/activerecord/test/fixtures/topics.yml
@@ -24,7 +24,7 @@ second:
 third:
   id: 3
   title: The Third Topic of the day
-  author_name: Nick
+  author_name: Carl
   written_on: 2005-07-15t15:28:00.0099+01:00
   content: I'm a troll
   approved: true
diff --git a/activerecord/test/schema/schema.rb b/activerecord/test/schema/schema.rb
index f5fba2f87d..b212e7cff2 100644
--- a/activerecord/test/schema/schema.rb
+++ b/activerecord/test/schema/schema.rb
@@ -485,6 +485,7 @@ ActiveRecord::Schema.define do
     t.integer  :parent_id
     t.string   :parent_title
     t.string   :type
+    t.string   :group
   end
 
   create_table :taggings, :force => true do |t|