Merge branch 'master' of github.com:lifo/docrails

24 files changed, 397 insertions, 48 deletions

diff --git a/activerecord/test/cases/associations/cascaded_eager_loading_test.rb b/activerecord/test/cases/associations/cascaded_eager_loading_test.rb
index 37c6f354a8..0742e311d9 100644
--- a/activerecord/test/cases/associations/cascaded_eager_loading_test.rb
+++ b/activerecord/test/cases/associations/cascaded_eager_loading_test.rb
@@ -10,7 +10,8 @@ require 'models/reply'
 require 'models/person'
 
 class CascadedEagerLoadingTest < ActiveRecord::TestCase
-  fixtures :authors, :mixins, :companies, :posts, :topics, :accounts, :comments, :categorizations, :people
+  fixtures :authors, :mixins, :companies, :posts, :topics, :accounts, :comments,
+           :categorizations, :people, :categories
 
   def test_eager_association_loading_with_cascaded_two_levels
     authors = Author.find(:all, :include=>{:posts=>:comments}, :order=>"authors.id")
diff --git a/activerecord/test/cases/associations/eager_test.rb b/activerecord/test/cases/associations/eager_test.rb
index 66fb5ac1e1..c00b8a1cde 100644
--- a/activerecord/test/cases/associations/eager_test.rb
+++ b/activerecord/test/cases/associations/eager_test.rb
@@ -79,6 +79,58 @@ class EagerAssociationTest < ActiveRecord::TestCase
     end
   end
 
+  def test_preloading_has_many_in_multiple_queries_with_more_ids_than_database_can_handle
+    Post.connection.expects(:ids_in_list_limit).at_least_once.returns(5)
+    posts = Post.find(:all, :include=>:comments)
+    assert_equal 7, posts.size
+  end
+
+  def test_preloading_has_many_in_one_queries_when_database_has_no_limit_on_ids_it_can_handle
+    Post.connection.expects(:ids_in_list_limit).at_least_once.returns(nil)
+    posts = Post.find(:all, :include=>:comments)
+    assert_equal 7, posts.size
+  end
+
+  def test_preloading_habtm_in_multiple_queries_with_more_ids_than_database_can_handle
+    Post.connection.expects(:ids_in_list_limit).at_least_once.returns(5)
+    posts = Post.find(:all, :include=>:categories)
+    assert_equal 7, posts.size
+  end
+
+  def test_preloading_habtm_in_one_queries_when_database_has_no_limit_on_ids_it_can_handle
+    Post.connection.expects(:ids_in_list_limit).at_least_once.returns(nil)
+    posts = Post.find(:all, :include=>:categories)
+    assert_equal 7, posts.size
+  end
+
+  def test_load_associated_records_in_one_query_when_adapter_has_no_limit
+    Post.connection.expects(:ids_in_list_limit).at_least_once.returns(nil)
+    Post.expects(:i_was_called).with([1,2,3,4,5,6,7]).returns([1])
+    associated_records = Post.send(:associated_records, [1,2,3,4,5,6,7]) do |some_ids|
+      Post.i_was_called(some_ids)
+    end
+    assert_equal [1], associated_records
+  end
+
+  def test_load_associated_records_in_several_queries_when_many_ids_passed
+    Post.connection.expects(:ids_in_list_limit).at_least_once.returns(5)
+    Post.expects(:i_was_called).with([1,2,3,4,5]).returns([1])
+    Post.expects(:i_was_called).with([6,7]).returns([6])
+    associated_records = Post.send(:associated_records, [1,2,3,4,5,6,7]) do |some_ids|
+      Post.i_was_called(some_ids)
+    end
+    assert_equal [1,6], associated_records
+  end
+
+  def test_load_associated_records_in_one_query_when_a_few_ids_passed
+    Post.connection.expects(:ids_in_list_limit).at_least_once.returns(5)
+    Post.expects(:i_was_called).with([1,2,3]).returns([1])
+    associated_records = Post.send(:associated_records, [1,2,3]) do |some_ids|
+      Post.i_was_called(some_ids)
+    end
+    assert_equal [1], associated_records
+  end
+
   def test_including_duplicate_objects_from_belongs_to
     popular_post = Post.create!(:title => 'foo', :body => "I like cars!")
     comment = popular_post.comments.create!(:body => "lol")
diff --git a/activerecord/test/cases/associations/has_many_associations_test.rb b/activerecord/test/cases/associations/has_many_associations_test.rb
index ecfc769f3a..33c53e695b 100644
--- a/activerecord/test/cases/associations/has_many_associations_test.rb
+++ b/activerecord/test/cases/associations/has_many_associations_test.rb
@@ -1282,4 +1282,25 @@ class HasManyAssociationsTest < ActiveRecord::TestCase
     comment = post.comments.build
     assert post.comments.include?(comment)
   end
+
+  def test_load_target_respects_protected_attributes
+    topic = Topic.create!
+    reply = topic.replies.create(:title => "reply 1")
+    reply.approved = false
+    reply.save!
+
+    # Save with a different object instance, so the instance that's still held
+    # in topic.relies doesn't know about the changed attribute.
+    reply2 = Reply.find(reply.id)
+    reply2.approved = true
+    reply2.save!
+
+    # Force loading the collection from the db. This will merge the existing
+    # object (reply) with what gets loaded from the db (which includes the
+    # changed approved attribute). approved is a protected attribute, so if mass
+    # assignment is used, it won't get updated and will still be false.
+    first = topic.replies.to_a.first
+    assert_equal reply.id, first.id
+    assert_equal true, first.approved?
+  end
 end
diff --git a/activerecord/test/cases/associations/inverse_associations_test.rb b/activerecord/test/cases/associations/inverse_associations_test.rb
index fa5c2e49df..081583038f 100644
--- a/activerecord/test/cases/associations/inverse_associations_test.rb
+++ b/activerecord/test/cases/associations/inverse_associations_test.rb
@@ -551,8 +551,8 @@ class InverseMultipleHasManyInversesForSameModel < ActiveRecord::TestCase
   def test_that_we_can_load_associations_that_have_the_same_reciprocal_name_from_different_models
     assert_nothing_raised(ActiveRecord::AssociationTypeMismatch) do
       i = Interest.find(:first)
-      z = i.zine
-      m = i.man
+      i.zine
+      i.man
     end
   end
 
diff --git a/activerecord/test/cases/associations_test.rb b/activerecord/test/cases/associations_test.rb
index dd8152b219..83c605d2bb 100644
--- a/activerecord/test/cases/associations_test.rb
+++ b/activerecord/test/cases/associations_test.rb
@@ -120,7 +120,7 @@ class AssociationsTest < ActiveRecord::TestCase
 
   def test_force_reload_is_uncached
     firm = Firm.create!("name" => "A New Firm, Inc")
-    client = Client.create!("name" => "TheClient.com", :firm => firm)
+    Client.create!("name" => "TheClient.com", :firm => firm)
     ActiveRecord::Base.cache do
       firm.clients.each {}
       assert_queries(0) { assert_not_nil firm.clients.each {} }
@@ -270,17 +270,17 @@ class OverridingAssociationsTest < ActiveRecord::TestCase
 
   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)
+    callbacks = PeopleList.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)
+    callbacks = DifferentPeopleList.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)
+    callbacks = PeopleList.before_add_for_has_many
     assert_equal([:enlist], callbacks)
-    callbacks = DifferentPeopleList.read_inheritable_attribute(:before_add_for_has_many)
+    callbacks = DifferentPeopleList.before_add_for_has_many
     assert_equal([], callbacks)
   end
 
diff --git a/activerecord/test/cases/attribute_methods_test.rb b/activerecord/test/cases/attribute_methods_test.rb
index ab9a65944f..bb0166a60c 100644
--- a/activerecord/test/cases/attribute_methods_test.rb
+++ b/activerecord/test/cases/attribute_methods_test.rb
@@ -568,7 +568,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
   def test_bulk_update_respects_access_control
     privatize("title=(value)")
 
-    assert_raise(ActiveRecord::UnknownAttributeError) { topic = @target.new(:title => "Rants about pants") }
+    assert_raise(ActiveRecord::UnknownAttributeError) { @target.new(:title => "Rants about pants") }
     assert_raise(ActiveRecord::UnknownAttributeError) { @target.new.attributes = { :title => "Ants in pants" } }
   end
 
diff --git a/activerecord/test/cases/autosave_association_test.rb b/activerecord/test/cases/autosave_association_test.rb
index 459f9fa55c..b13cb2d7a2 100644
--- a/activerecord/test/cases/autosave_association_test.rb
+++ b/activerecord/test/cases/autosave_association_test.rb
@@ -355,8 +355,6 @@ class TestDefaultAutosaveAssociationOnAHasManyAssociation < ActiveRecord::TestCa
   end
 
   def test_invalid_adding_before_save
-    no_of_firms = Firm.count
-    no_of_clients = Client.count
     new_firm = Firm.new("name" => "A New Firm, Inc")
     new_firm.clients_of_firm.concat([c = Client.new, Client.new("name" => "Apple")])
     assert !c.persisted?
@@ -461,7 +459,7 @@ class TestDefaultAutosaveAssociationOnAHasManyAssociation < ActiveRecord::TestCa
 
   def test_build_many_before_save
     company = companies(:first_firm)
-    new_clients = assert_no_queries { company.clients_of_firm.build([{"name" => "Another Client"}, {"name" => "Another Client II"}]) }
+    assert_no_queries { company.clients_of_firm.build([{"name" => "Another Client"}, {"name" => "Another Client II"}]) }
 
     company.name += '-changed'
     assert_queries(3) { assert company.save }
@@ -481,7 +479,7 @@ class TestDefaultAutosaveAssociationOnAHasManyAssociation < ActiveRecord::TestCa
 
   def test_build_many_via_block_before_save
     company = companies(:first_firm)
-    new_clients = assert_no_queries do
+    assert_no_queries do
       company.clients_of_firm.build([{"name" => "Another Client"}, {"name" => "Another Client II"}]) do |client|
         client.name = "changed"
       end
diff --git a/activerecord/test/cases/base_test.rb b/activerecord/test/cases/base_test.rb
index 9f2b0c9c86..26f388ca46 100644
--- a/activerecord/test/cases/base_test.rb
+++ b/activerecord/test/cases/base_test.rb
@@ -182,7 +182,7 @@ class BasicsTest < ActiveRecord::TestCase
 
   def test_initialize_with_invalid_attribute
     begin
-      topic = Topic.new({ "title" => "test",
+      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)
@@ -397,6 +397,15 @@ class BasicsTest < ActiveRecord::TestCase
     assert_not_equal Topic.new, Topic.new
   end
 
+  def test_equality_of_destroyed_records
+    topic_1 = Topic.new(:title => 'test_1')
+    topic_1.save
+    topic_2 = Topic.find(topic_1.id)
+    topic_1.destroy
+    assert_equal topic_1, topic_2
+    assert_equal topic_2, topic_1
+  end
+
   def test_hashing
     assert_equal [ Topic.find(1) ], [ Topic.find(2).topic ] & [ Topic.find(1) ]
   end
@@ -963,7 +972,6 @@ class BasicsTest < ActiveRecord::TestCase
   end
 
   def test_nil_serialized_attribute_with_class_constraint
-    myobj = MyObject.new('value1', 'value2')
     topic = Topic.new
     assert_nil topic.content
   end
diff --git a/activerecord/test/cases/calculations_test.rb b/activerecord/test/cases/calculations_test.rb
index 61fbf01a50..5cb8485b4b 100644
--- a/activerecord/test/cases/calculations_test.rb
+++ b/activerecord/test/cases/calculations_test.rb
@@ -54,6 +54,19 @@ class CalculationsTest < ActiveRecord::TestCase
     c = Account.sum(:credit_limit, :group => :firm_id)
     [1,6,2].each { |firm_id| assert c.keys.include?(firm_id) }
   end
+  
+  def test_should_group_by_multiple_fields
+    c = Account.count(:all, :group => ['firm_id', :credit_limit])
+    [ [nil, 50], [1, 50], [6, 50], [6, 55], [9, 53], [2, 60] ].each { |firm_and_limit| assert c.keys.include?(firm_and_limit) }
+  end
+
+  def test_should_group_by_multiple_fields_having_functions
+    c = Topic.group(:author_name, 'COALESCE(type, title)').count(:all)
+    assert_equal 1, c[["Carl", "The Third Topic of the day"]]
+    assert_equal 1, c[["Mary", "Reply"]]
+    assert_equal 1, c[["David", "The First Topic"]]
+    assert_equal 1, c[["Carl", "Reply"]]
+  end
 
   def test_should_group_by_summed_field
     c = Account.sum(:credit_limit, :group => :firm_id)
diff --git a/activerecord/test/cases/finder_test.rb b/activerecord/test/cases/finder_test.rb
index 39ce47d9d6..31e4981a1d 100644
--- a/activerecord/test/cases/finder_test.rb
+++ b/activerecord/test/cases/finder_test.rb
@@ -949,7 +949,7 @@ class FinderTest < ActiveRecord::TestCase
 
   # http://dev.rubyonrails.org/ticket/6778
   def test_find_ignores_previously_inserted_record
-    post = Post.create!(:title => 'test', :body => 'it out')
+    Post.create!(:title => 'test', :body => 'it out')
     assert_equal [], Post.find_all_by_id(nil)
   end
 
diff --git a/activerecord/test/cases/fixtures_test.rb b/activerecord/test/cases/fixtures_test.rb
index d5ef30e137..9ce163a00f 100644
--- a/activerecord/test/cases/fixtures_test.rb
+++ b/activerecord/test/cases/fixtures_test.rb
@@ -58,7 +58,7 @@ class FixturesTest < ActiveRecord::TestCase
   end
 
   def test_inserts
-    topics = create_fixtures("topics")
+    create_fixtures("topics")
     first_row = ActiveRecord::Base.connection.select_one("SELECT * FROM topics WHERE author_name = 'David'")
     assert_equal("The First Topic", first_row["title"])
 
@@ -114,7 +114,7 @@ class FixturesTest < ActiveRecord::TestCase
   end
 
   def test_insert_with_datetime
-    topics = create_fixtures("tasks")
+    create_fixtures("tasks")
     first = Task.find(1)
     assert first
   end
@@ -240,7 +240,7 @@ if Account.connection.respond_to?(:reset_pk_sequence!)
 
     def test_create_fixtures_resets_sequences_when_not_cached
       @instances.each do |instance|
-        max_id = create_fixtures(instance.class.table_name).inject(0) do |_max_id, (name, fixture)|
+        max_id = create_fixtures(instance.class.table_name).inject(0) do |_max_id, (_, fixture)|
           fixture_id = fixture['id'].to_i
           fixture_id > _max_id ? fixture_id : _max_id
         end
diff --git a/activerecord/test/cases/helper.rb b/activerecord/test/cases/helper.rb
index 52f26b71f5..f9bbc5299b 100644
--- a/activerecord/test/cases/helper.rb
+++ b/activerecord/test/cases/helper.rb
@@ -13,11 +13,6 @@ require 'active_record'
 require 'active_support/dependencies'
 require 'connection'
 
-begin
-  require 'ruby-debug'
-rescue LoadError
-end
-
 # Show backtraces for deprecated behavior for quicker cleanup.
 ActiveSupport::Deprecation.debug = true
 
diff --git a/activerecord/test/cases/invertible_migration_test.rb b/activerecord/test/cases/invertible_migration_test.rb
new file mode 100644
index 0000000000..afec64750e
--- /dev/null
+++ b/activerecord/test/cases/invertible_migration_test.rb
@@ -0,0 +1,57 @@
+require "cases/helper"
+
+module ActiveRecord
+  class InvertibleMigrationTest < ActiveRecord::TestCase
+    class SilentMigration < ActiveRecord::Migration
+      def write(text = '')
+        # sssshhhhh!!
+      end
+    end
+
+    class InvertibleMigration < SilentMigration
+      def change
+        create_table("horses") do |t|
+          t.column :content, :text
+          t.column :remind_at, :datetime
+        end
+      end
+    end
+
+    class NonInvertibleMigration < SilentMigration
+      def change
+        create_table("horses") do |t|
+          t.column :content, :text
+          t.column :remind_at, :datetime
+        end
+        remove_column "horses", :content
+      end
+    end
+
+    def teardown
+      if ActiveRecord::Base.connection.table_exists?("horses")
+        ActiveRecord::Base.connection.drop_table("horses")
+      end
+    end
+
+    def test_no_reverse
+      migration = NonInvertibleMigration.new
+      migration.migrate(:up)
+      assert_raises(IrreversibleMigration) do
+        migration.migrate(:down)
+      end
+    end
+
+    def test_up
+      migration = InvertibleMigration.new
+      migration.migrate(:up)
+      assert migration.connection.table_exists?("horses"), "horses should exist"
+    end
+
+    def test_down
+      migration = InvertibleMigration.new
+      migration.migrate :up
+      migration.migrate :down
+      assert !migration.connection.table_exists?("horses")
+    end
+  end
+end
diff --git a/activerecord/test/cases/migration/command_recorder_test.rb b/activerecord/test/cases/migration/command_recorder_test.rb
new file mode 100644
index 0000000000..ea2292dda5
--- /dev/null
+++ b/activerecord/test/cases/migration/command_recorder_test.rb
@@ -0,0 +1,108 @@
+require "cases/helper"
+
+module ActiveRecord
+  class Migration
+    class CommandRecorderTest < ActiveRecord::TestCase
+      def setup
+        @recorder = CommandRecorder.new
+      end
+
+      def test_respond_to_delegates
+        recorder = CommandRecorder.new(Class.new {
+          def america; end
+        }.new)
+        assert recorder.respond_to?(:america)
+      end
+
+      def test_send_calls_super
+        assert_raises(NoMethodError) do
+          @recorder.send(:create_table, :horses)
+        end
+      end
+
+      def test_send_delegates_to_record
+        recorder = CommandRecorder.new(Class.new {
+          def create_table(name); end
+        }.new)
+        assert recorder.respond_to?(:create_table), 'respond_to? create_table'
+        recorder.send(:create_table, :horses)
+        assert_equal [[:create_table, [:horses]]], recorder.commands
+      end
+
+      def test_unknown_commands_raise_exception
+        @recorder.record :execute, ['some sql']
+        assert_raises(ActiveRecord::IrreversibleMigration) do
+          @recorder.inverse
+        end
+      end
+
+      def test_record
+        @recorder.record :create_table, [:system_settings]
+        assert_equal 1, @recorder.commands.length
+      end
+
+      def test_inverse
+        @recorder.record :create_table, [:system_settings]
+        assert_equal 1, @recorder.inverse.length
+
+        @recorder.record :rename_table, [:old, :new]
+        assert_equal 2, @recorder.inverse.length
+      end
+
+      def test_inverted_commands_are_reveresed
+        @recorder.record :create_table, [:hello]
+        @recorder.record :create_table, [:world]
+        tables = @recorder.inverse.map(&:last)
+        assert_equal [[:world], [:hello]], tables
+      end
+
+      def test_invert_create_table
+        @recorder.record :create_table, [:system_settings]
+        drop_table = @recorder.inverse.first
+        assert_equal [:drop_table, [:system_settings]], drop_table
+      end
+
+      def test_invert_rename_table
+        @recorder.record :rename_table, [:old, :new]
+        rename = @recorder.inverse.first
+        assert_equal [:rename_table, [:new, :old]], rename
+      end
+
+      def test_invert_add_column
+        @recorder.record :add_column, [:table, :column, :type, {}]
+        remove = @recorder.inverse.first
+        assert_equal [:remove_column, [:table, :column]], remove
+      end
+
+      def test_invert_rename_column
+        @recorder.record :rename_column, [:table, :old, :new]
+        rename = @recorder.inverse.first
+        assert_equal [:rename_column, [:table, :new, :old]], rename
+      end
+
+      def test_invert_add_index
+        @recorder.record :add_index, [:table, [:one, :two], {:options => true}]
+        remove = @recorder.inverse.first
+        assert_equal [:remove_index, [:table, {:column => [:one, :two]}]], remove
+      end
+
+      def test_invert_rename_index
+        @recorder.record :rename_index, [:old, :new]
+        rename = @recorder.inverse.first
+        assert_equal [:rename_index, [:new, :old]], rename
+      end
+
+      def test_invert_add_timestamps
+        @recorder.record :add_timestamps, [:table]
+        remove = @recorder.inverse.first
+        assert_equal [:remove_timestamps, [:table]], remove
+      end
+
+      def test_invert_remove_timestamps
+        @recorder.record :remove_timestamps, [:table]
+        add = @recorder.inverse.first
+        assert_equal [:add_timestamps, [:table]], add
+      end
+    end
+  end
+end
diff --git a/activerecord/test/cases/migration_test.rb b/activerecord/test/cases/migration_test.rb
index e6eef805cf..3037d73a1b 100644
--- a/activerecord/test/cases/migration_test.rb
+++ b/activerecord/test/cases/migration_test.rb
@@ -18,10 +18,11 @@ if ActiveRecord::Base.connection.supports_migrations?
   class ActiveRecord::Migration
     class <<self
       attr_accessor :message_count
-      def puts(text="")
-        self.message_count ||= 0
-        self.message_count += 1
-      end
+    end
+
+    def puts(text="")
+      self.class.message_count ||= 0
+      self.class.message_count += 1
     end
   end
 
@@ -1165,6 +1166,44 @@ if ActiveRecord::Base.connection.supports_migrations?
       assert_raise(ActiveRecord::StatementInvalid) { Reminder.find(:first) }
     end
 
+    class MockMigration < ActiveRecord::Migration
+      attr_reader :went_up, :went_down
+      def initialize
+        @went_up   = false
+        @went_down = false
+      end
+
+      def up
+        @went_up = true
+        super
+      end
+
+      def down
+        @went_down = true
+        super
+      end
+    end
+
+    def test_instance_based_migration_up
+      migration = MockMigration.new
+      assert !migration.went_up, 'have not gone up'
+      assert !migration.went_down, 'have not gone down'
+
+      migration.migrate :up
+      assert migration.went_up, 'have gone up'
+      assert !migration.went_down, 'have not gone down'
+    end
+
+    def test_instance_based_migration_down
+      migration = MockMigration.new
+      assert !migration.went_up, 'have not gone up'
+      assert !migration.went_down, 'have not gone down'
+
+      migration.migrate :down
+      assert !migration.went_up, 'have gone up'
+      assert migration.went_down, 'have not gone down'
+    end
+
     def test_migrator_one_up
       assert !Person.column_methods_hash.include?(:last_name)
       assert !Reminder.table_exists?
@@ -1312,20 +1351,20 @@ if ActiveRecord::Base.connection.supports_migrations?
 
     def test_migrator_verbosity
       ActiveRecord::Migrator.up(MIGRATIONS_ROOT + "/valid", 1)
-      assert PeopleHaveLastNames.message_count > 0
+      assert_operator PeopleHaveLastNames.message_count, :>, 0
       PeopleHaveLastNames.message_count = 0
 
       ActiveRecord::Migrator.down(MIGRATIONS_ROOT + "/valid", 0)
-      assert PeopleHaveLastNames.message_count > 0
+      assert_operator PeopleHaveLastNames.message_count, :>, 0
       PeopleHaveLastNames.message_count = 0
     end
 
     def test_migrator_verbosity_off
       PeopleHaveLastNames.verbose = false
       ActiveRecord::Migrator.up(MIGRATIONS_ROOT + "/valid", 1)
-      assert PeopleHaveLastNames.message_count.zero?
+      assert_equal 0, PeopleHaveLastNames.message_count
       ActiveRecord::Migrator.down(MIGRATIONS_ROOT + "/valid", 0)
-      assert PeopleHaveLastNames.message_count.zero?
+      assert_equal 0, PeopleHaveLastNames.message_count
     end
 
     def test_migrator_going_down_due_to_version_target
@@ -1947,7 +1986,7 @@ if ActiveRecord::Base.connection.supports_migrations?
       @migrations_path = MIGRATIONS_ROOT + "/valid_with_timestamps"
       @existing_migrations = Dir[@migrations_path + "/*.rb"]
 
-      Time.travel_to(created_at = Time.utc(2010, 7, 26, 10, 10, 10)) do
+      Time.travel_to(Time.utc(2010, 7, 26, 10, 10, 10)) do
         copied = ActiveRecord::Migration.copy(@migrations_path, {:bukkits => MIGRATIONS_ROOT + "/to_copy_with_timestamps"})
         assert File.exists?(@migrations_path + "/20100726101010_people_have_hobbies.rb")
         assert File.exists?(@migrations_path + "/20100726101011_people_have_descriptions.rb")
@@ -1972,7 +2011,7 @@ if ActiveRecord::Base.connection.supports_migrations?
       sources[:bukkits] = MIGRATIONS_ROOT + "/to_copy_with_timestamps"
       sources[:omg]     = MIGRATIONS_ROOT + "/to_copy_with_timestamps2"
 
-      Time.travel_to(created_at = Time.utc(2010, 7, 26, 10, 10, 10)) do
+      Time.travel_to(Time.utc(2010, 7, 26, 10, 10, 10)) do
         copied = ActiveRecord::Migration.copy(@migrations_path, sources)
         assert File.exists?(@migrations_path + "/20100726101010_people_have_hobbies.rb")
         assert File.exists?(@migrations_path + "/20100726101011_people_have_descriptions.rb")
@@ -1992,7 +2031,7 @@ if ActiveRecord::Base.connection.supports_migrations?
       @migrations_path = MIGRATIONS_ROOT + "/valid_with_timestamps"
       @existing_migrations = Dir[@migrations_path + "/*.rb"]
 
-      Time.travel_to(created_at = Time.utc(2010, 2, 20, 10, 10, 10)) do
+      Time.travel_to(Time.utc(2010, 2, 20, 10, 10, 10)) do
         ActiveRecord::Migration.copy(@migrations_path, {:bukkits => MIGRATIONS_ROOT + "/to_copy_with_timestamps"})
         assert File.exists?(@migrations_path + "/20100301010102_people_have_hobbies.rb")
         assert File.exists?(@migrations_path + "/20100301010103_people_have_descriptions.rb")
@@ -2024,11 +2063,26 @@ if ActiveRecord::Base.connection.supports_migrations?
       clear
     end
 
+    def test_copying_migrations_to_non_existing_directory
+      @migrations_path = MIGRATIONS_ROOT + "/non_existing"
+      @existing_migrations = []
+
+      Time.travel_to(Time.utc(2010, 7, 26, 10, 10, 10)) do
+        copied = ActiveRecord::Migration.copy(@migrations_path, {:bukkits => MIGRATIONS_ROOT + "/to_copy_with_timestamps"})
+        assert File.exists?(@migrations_path + "/20100726101010_people_have_hobbies.rb")
+        assert File.exists?(@migrations_path + "/20100726101011_people_have_descriptions.rb")
+        assert_equal 2, copied.length
+      end
+    ensure
+      clear
+      Dir.delete(@migrations_path)
+    end
+
     def test_copying_migrations_to_empty_directory
       @migrations_path = MIGRATIONS_ROOT + "/empty"
       @existing_migrations = []
 
-      Time.travel_to(created_at = Time.utc(2010, 7, 26, 10, 10, 10)) do
+      Time.travel_to(Time.utc(2010, 7, 26, 10, 10, 10)) do
         copied = ActiveRecord::Migration.copy(@migrations_path, {:bukkits => MIGRATIONS_ROOT + "/to_copy_with_timestamps"})
         assert File.exists?(@migrations_path + "/20100726101010_people_have_hobbies.rb")
         assert File.exists?(@migrations_path + "/20100726101011_people_have_descriptions.rb")
diff --git a/activerecord/test/cases/named_scope_test.rb b/activerecord/test/cases/named_scope_test.rb
index fb24c65fff..6ac3e3fc56 100644
--- a/activerecord/test/cases/named_scope_test.rb
+++ b/activerecord/test/cases/named_scope_test.rb
@@ -122,7 +122,7 @@ class NamedScopeTest < ActiveRecord::TestCase
       :joins => 'JOIN authors ON authors.id = posts.author_id',
       :conditions => [ 'authors.author_address_id = ?', address.id ]
     )
-    assert_equal posts_with_authors_at_address_titles, Post.with_authors_at_address(address).find(:all, :select => 'title')
+    assert_equal posts_with_authors_at_address_titles.map(&:title), Post.with_authors_at_address(address).find(:all, :select => 'title').map(&:title)
   end
 
   def test_scope_with_object
diff --git a/activerecord/test/cases/persistence_test.rb b/activerecord/test/cases/persistence_test.rb
index 07262f56be..8ca9d626d1 100644
--- a/activerecord/test/cases/persistence_test.rb
+++ b/activerecord/test/cases/persistence_test.rb
@@ -192,7 +192,6 @@ class PersistencesTest < ActiveRecord::TestCase
     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
@@ -270,7 +269,7 @@ class PersistencesTest < ActiveRecord::TestCase
   end
 
   def test_record_not_found_exception
-    assert_raise(ActiveRecord::RecordNotFound) { topicReloaded = Topic.find(99999) }
+    assert_raise(ActiveRecord::RecordNotFound) { Topic.find(99999) }
   end
 
   def test_update_all
diff --git a/activerecord/test/cases/query_cache_test.rb b/activerecord/test/cases/query_cache_test.rb
index 5bb21a54bd..33916c4e46 100644
--- a/activerecord/test/cases/query_cache_test.rb
+++ b/activerecord/test/cases/query_cache_test.rb
@@ -133,7 +133,6 @@ class QueryCacheExpiryTest < ActiveRecord::TestCase
   def test_cache_is_expired_by_habtm_delete
     ActiveRecord::Base.connection.expects(:clear_query_cache).times(2)
     ActiveRecord::Base.cache do
-      c = Category.find(1)
       p = Post.find(1)
       assert p.categories.any?
       p.categories.delete_all
diff --git a/activerecord/test/cases/relation_scoping_test.rb b/activerecord/test/cases/relation_scoping_test.rb
index a27e2e72cd..dae9721a63 100644
--- a/activerecord/test/cases/relation_scoping_test.rb
+++ b/activerecord/test/cases/relation_scoping_test.rb
@@ -254,13 +254,11 @@ class HasManyScopingTest< ActiveRecord::TestCase
   end
 
   def test_should_maintain_default_scope_on_associations
-    person = people(:michael)
     magician = BadReference.find(1)
     assert_equal [magician], people(:michael).bad_references
   end
 
   def test_should_default_scope_on_associations_is_overriden_by_association_conditions
-    person = people(:michael)
     assert_equal [], people(:michael).fixed_bad_references
   end
 
diff --git a/activerecord/test/cases/relations_test.rb b/activerecord/test/cases/relations_test.rb
index b44c716db8..535bcd4396 100644
--- a/activerecord/test/cases/relations_test.rb
+++ b/activerecord/test/cases/relations_test.rb
@@ -426,6 +426,52 @@ class RelationTest < ActiveRecord::TestCase
     assert_blank authors.all
   end
 
+  def test_where_with_ar_object
+    author = Author.first
+    authors = Author.scoped.where(:id => author)
+    assert_equal 1, authors.all.length
+  end
+
+  def test_find_with_list_of_ar
+    author = Author.first
+    authors = Author.find([author])
+    assert_equal author, authors.first
+  end
+
+  class Mary < Author; end
+
+  def test_find_by_classname
+    Author.create!(:name => Mary.name)
+    assert_equal 1, Author.where(:name => Mary).size
+  end
+
+  def test_find_by_id_with_list_of_ar
+    author = Author.first
+    authors = Author.find_by_id([author])
+    assert_equal author, authors
+  end
+
+  def test_find_all_using_where_twice_should_or_the_relation
+    david = authors(:david)
+    relation = Author.unscoped
+    relation = relation.where(:name => david.name)
+    relation = relation.where(:name => 'Santiago')
+    relation = relation.where(:id => david.id)
+    assert_equal [david], relation.all
+  end
+
+  def test_find_all_with_multiple_ors
+    david = authors(:david)
+    relation = [
+      { :name => david.name },
+      { :name => 'Santiago' },
+      { :name => 'tenderlove' },
+    ].inject(Author.unscoped) do |memo, param|
+      memo.where(param)
+    end
+    assert_equal [david], relation.all
+  end
+
   def test_exists
     davids = Author.where(:name => 'David')
     assert davids.exists?
diff --git a/activerecord/test/cases/timestamp_test.rb b/activerecord/test/cases/timestamp_test.rb
index eb93761fb2..70c098bc6d 100644
--- a/activerecord/test/cases/timestamp_test.rb
+++ b/activerecord/test/cases/timestamp_test.rb
@@ -113,7 +113,7 @@ class TimestampTest < ActiveRecord::TestCase
 
     pet = Pet.first
     owner = pet.owner
-    owner.update_attribute(:happy_at, (time = 3.days.ago))
+    owner.update_attribute(:happy_at, 3.days.ago)
     previously_owner_updated_at = owner.updated_at
 
     pet.name = "I'm a parrot"
diff --git a/activerecord/test/cases/transactions_test.rb b/activerecord/test/cases/transactions_test.rb
index dd9de3510b..b0ccd71836 100644
--- a/activerecord/test/cases/transactions_test.rb
+++ b/activerecord/test/cases/transactions_test.rb
@@ -163,7 +163,7 @@ class TransactionTest < ActiveRecord::TestCase
         @first.author_name += '_this_should_not_end_up_in_the_db'
         @first.save!
         flunk
-      rescue => e
+      rescue
         assert_equal original_author_name, @first.reload.author_name
         assert_equal nbooks_before_save, Book.count
       ensure
diff --git a/activerecord/test/cases/validations/association_validation_test.rb b/activerecord/test/cases/validations/association_validation_test.rb
index 1246dd4276..56e345990f 100644
--- a/activerecord/test/cases/validations/association_validation_test.rb
+++ b/activerecord/test/cases/validations/association_validation_test.rb
@@ -17,7 +17,7 @@ class AssociationValidationTest < ActiveRecord::TestCase
     o = Owner.new('name' => 'nopets')
     assert !o.save
     assert o.errors[:pets].any?
-    pet = o.pets.build('name' => 'apet')
+    o.pets.build('name' => 'apet')
     assert o.valid?
   end
 
@@ -27,7 +27,7 @@ class AssociationValidationTest < ActiveRecord::TestCase
     assert !o.save
     assert o.errors[:pets].any?
 
-    pet = o.pets.build('name' => 'apet')
+    o.pets.build('name' => 'apet')
     assert o.valid?
 
     2.times { o.pets.build('name' => 'apet') }
diff --git a/activerecord/test/cases/validations/uniqueness_validation_test.rb b/activerecord/test/cases/validations/uniqueness_validation_test.rb
index 9a863c25a8..679d67553b 100644
--- a/activerecord/test/cases/validations/uniqueness_validation_test.rb
+++ b/activerecord/test/cases/validations/uniqueness_validation_test.rb
@@ -60,7 +60,7 @@ class UniquenessValidationTest < ActiveRecord::TestCase
 
   def test_validates_uniqueness_with_validates
     Topic.validates :title, :uniqueness => true
-    t = Topic.create!('title' => 'abc')
+    Topic.create!('title' => 'abc')
 
     t2 = Topic.new('title' => 'abc')
     assert !t2.valid?
@@ -201,7 +201,7 @@ class UniquenessValidationTest < ActiveRecord::TestCase
 
   def test_validate_case_sensitive_uniqueness_with_attribute_passed_as_integer
     Topic.validates_uniqueness_of(:title, :case_sensitve => true)
-    t = Topic.create!('title' => 101)
+    Topic.create!('title' => 101)
 
     t2 = Topic.new('title' => 101)
     assert !t2.valid?