ibm_db 2.5.6 → 2.5.7

data/test/cases/calculations_test.rb

@@ -23,6 +23,18 @@ class CalculationsTest < ActiveRecord::TestCase
     assert_equal 53.0, value
   end
 
+  def test_should_return_decimal_average_of_integer_field
+    return if current_adapter?(:IBM_DBAdapter) #average cannot be a decimal value when applied on integer field
+    value = Account.average(:id)
+    assert_equal 3.5, value
+  end
+
+  def test_should_return_integer_average_if_db_returns_such
+    Account.connection.stubs :select_value => 3
+    value = Account.average(:id)
+    assert_equal 3, value
+  end
+
   def test_should_return_nil_as_average
     assert_nil NumericData.average(:bank_balance)
   end
@@ -55,6 +67,19 @@ class CalculationsTest < ActiveRecord::TestCase
     [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)
     assert_equal 50,   c[1]
@@ -85,6 +110,51 @@ class CalculationsTest < ActiveRecord::TestCase
     assert_equal [2, 6], c.keys.compact
   end
 
+  def test_limit_should_apply_before_count
+    accounts = Account.limit(3).where('firm_id IS NOT NULL')
+
+    assert_equal 3, accounts.count(:firm_id)
+    assert_equal 3, accounts.select(:firm_id).count
+  end
+
+  def test_count_should_shortcut_with_limit_zero
+    accounts = Account.limit(0)
+
+    assert_no_queries { assert_equal 0, accounts.count }
+  end
+
+  def test_limit_is_kept
+    return if current_adapter?(:OracleAdapter, :IBM_DBAdapter)
+
+    queries = assert_sql { Account.limit(1).count }
+    assert_equal 1, queries.length
+    assert_match(/LIMIT/, queries.first)
+  end
+
+  def test_offset_is_kept
+    return if current_adapter?(:OracleAdapter,:IBM_DBAdapter)
+
+    queries = assert_sql { Account.offset(1).count }
+    assert_equal 1, queries.length
+    assert_match(/OFFSET/, queries.first)
+  end
+
+  def test_limit_with_offset_is_kept
+    return if current_adapter?(:OracleAdapter,:IBM_DBAdapter)
+
+    queries = assert_sql { Account.limit(1).offset(1).count }
+    assert_equal 1, queries.length
+    assert_match(/LIMIT/, queries.first)
+    assert_match(/OFFSET/, queries.first)
+  end
+
+  def test_no_limit_no_offset
+    queries = assert_sql { Account.count }
+    assert_equal 1, queries.length
+    assert_no_match(/LIMIT/, queries.first)
+    assert_no_match(/OFFSET/, queries.first)
+  end
+
   def test_should_group_by_summed_field_having_condition
     c = Account.sum(:credit_limit, :group => :firm_id,
                                    :having => 'sum(credit_limit) > 50')
@@ -101,6 +171,13 @@ class CalculationsTest < ActiveRecord::TestCase
     assert_equal 60,  c[2]
   end
 
+  def test_should_group_by_summed_field_having_condition_from_select
+    c = Account.select("MIN(credit_limit) AS min_credit_limit").group(:firm_id).having("min_credit_limit > 50").sum(:credit_limit)
+    assert_nil       c[1]
+    assert_equal 60, c[2]
+    assert_equal 53, c[9]
+  end
+
   def test_should_group_by_summed_association
     c = Account.sum(:credit_limit, :group => :firm)
     assert_equal 50,   c[companies(:first_firm)]
@@ -166,11 +243,7 @@ class CalculationsTest < ActiveRecord::TestCase
   end
 
   def test_should_group_by_association_with_non_numeric_foreign_key
-    if( ActiveRecord::Base.connection.respond_to?(:pstmt_support_on) && ActiveRecord::Base.connection.pstmt_support_on == true )
-      ActiveRecord::Base.connection.expects(:prepared_select).returns([{"count_all" => 1, "firm_id" => "ABC"}])
-    else
-      ActiveRecord::Base.connection.expects(:select_all).returns([{"count_all" => 1, "firm_id" => "ABC"}])
-    end
+    ActiveRecord::Base.connection.expects(:select_all).returns([{"count_all" => 1, "firm_id" => "ABC"}])
 
     firm = mock()
     firm.expects(:id).returns("ABC")
@@ -254,6 +327,17 @@ class CalculationsTest < ActiveRecord::TestCase
     assert_equal 4, Account.count(:distinct => true, :include => :firm, :select => :credit_limit)
   end
 
+  def test_should_not_perform_joined_include_by_default
+    assert_equal Account.count, Account.includes(:firm).count
+    queries = assert_sql { Account.includes(:firm).count }
+    assert_no_match(/join/i, queries.last)
+  end
+
+  def test_should_perform_joined_include_when_referencing_included_tables
+    joined_count = Account.includes(:firm).where(:companies => {:name => '37signals'}).count
+    assert_equal 1, joined_count
+  end
+
   def test_should_count_scoped_select
     Account.update_all("credit_limit = NULL")
     assert_equal 0, Account.scoped(:select => "credit_limit").count
@@ -261,8 +345,8 @@ class CalculationsTest < ActiveRecord::TestCase
 
   def test_should_count_scoped_select_with_options
     Account.update_all("credit_limit = NULL")
-    Account.last.update_attribute('credit_limit', 49)
-    Account.first.update_attribute('credit_limit', 51)
+    Account.last.update_column('credit_limit', 49)
+    Account.first.update_column('credit_limit', 51)
 
     assert_equal 1, Account.scoped(:select => "credit_limit").count(:conditions => ['credit_limit >= 50'])
   end
@@ -340,7 +424,7 @@ class CalculationsTest < ActiveRecord::TestCase
   end
 
   def test_from_option_with_specified_index
-    if Edge.connection.adapter_name == 'MySQL'
+    if Edge.connection.adapter_name == 'MySQL' or Edge.connection.adapter_name == 'Mysql2'
       assert_equal Edge.count(:all), Edge.count(:all, :from => 'edges USE INDEX(unique_edge_index)')
       assert_equal Edge.count(:all, :conditions => 'sink_id < 5'),
           Edge.count(:all, :from => 'edges USE INDEX(unique_edge_index)', :conditions => 'sink_id < 5')

data/test/cases/migration_test.rb

@@ -5,10 +5,8 @@ require 'models/person'
 require 'models/topic'
 require 'models/developer'
 
-require MIGRATIONS_ROOT + "/valid/1_people_have_last_names"
 require MIGRATIONS_ROOT + "/valid/2_we_need_reminders"
 require MIGRATIONS_ROOT + "/decimal/1_give_me_big_numbers"
-require MIGRATIONS_ROOT + "/interleaved/pass_3/2_i_raise_on_down"
 
 if ActiveRecord::Base.connection.supports_migrations?
   class BigNumber < ActiveRecord::Base; end
@@ -16,12 +14,13 @@ if ActiveRecord::Base.connection.supports_migrations?
   class Reminder < ActiveRecord::Base; end
 
   class ActiveRecord::Migration
-    class <<self
+    class << self
       attr_accessor :message_count
-      def puts(text="")
-        self.message_count ||= 0
-        self.message_count += 1
-      end
+    end
+
+    def puts(text="")
+      ActiveRecord::Migration.message_count ||= 0
+      ActiveRecord::Migration.message_count += 1
     end
   end
 
@@ -46,6 +45,7 @@ if ActiveRecord::Base.connection.supports_migrations?
 
   class MigrationTest < ActiveRecord::TestCase
     self.use_transactional_fixtures = false
+
     if (current_adapter?(:IBM_DBAdapter))
       #Rename is supported only for server zOS 9 , DB2 COBRA and Informix
       server_type = ActiveRecord::Base.connection.servertype.class.name
@@ -58,7 +58,7 @@ if ActiveRecord::Base.connection.supports_migrations?
 
     def setup
       ActiveRecord::Migration.verbose = true
-      PeopleHaveLastNames.message_count = 0
+      ActiveRecord::Migration.message_count = 0
     end
 
     def teardown
@@ -118,7 +118,7 @@ if ActiveRecord::Base.connection.supports_migrations?
       # Note: changed index name from "key" to "key_idx" since "key" is a Firebird reserved word
       # OpenBase does not have named indexes.  You must specify a single column name
       unless current_adapter?(:OpenBaseAdapter)
-	    unless current_adapter?(:IBM_DBAdapter) #cannot assign a integer value to string column
+        unless current_adapter?(:IBM_DBAdapter)
           Person.update_all "#{Person.connection.quote_column_name 'key'}=#{Person.connection.quote_column_name 'id'}" #some databases (including sqlite2 won't add a unique index if existing data non unique)
         else
           Person.update_all "#{Person.connection.quote_column_name 'key'}=#{Person.connection.quote_column_name 'first_name'}"
@@ -242,9 +242,9 @@ if ActiveRecord::Base.connection.supports_migrations?
     end
 
     unless current_adapter?(:IBM_DBAdapter)
-      # Cannot add a primary key to a table with some rows already in it as it violates the unique constraint
+      # For DB2: Cannot add a primary key to a table with some rows already in it as it violates the unique constraint
       # Secondly GENERATED BY DEFAULT AS IDENTITY cannot be applied in a alter table command.
-      # as this will be wrong sql syntax for DB2
+      # as this will be wrong sql syntax for DB
       def test_add_column_with_primary_key_attribute
         testing_table_with_only_foo_attribute do |connection|
           assert_nothing_raised { connection.add_column :testings, :id, :primary_key }
@@ -280,16 +280,14 @@ if ActiveRecord::Base.connection.supports_migrations?
 
     def test_create_table_with_defaults
       # MySQL doesn't allow defaults on TEXT or BLOB columns.
-      mysql = current_adapter?(:MysqlAdapter)
-      ibm_ids_zOS = ActiveRecord::Base.connection.servertype.class.name.include?('::IBM_IDS')||
-        ActiveRecord::Base.connection.servertype.class.name.include?('::IBM_DB2_ZOS')
-    
+      mysql = current_adapter?(:MysqlAdapter) || current_adapter?(:Mysql2Adapter)
+
       Person.connection.create_table :testings do |t|
         t.column :one, :string, :default => "hello"
         t.column :two, :boolean, :default => true
         t.column :three, :boolean, :default => false
         t.column :four, :integer, :default => 1
-        t.column :five, :text, :default => "hello" unless mysql || ibm_ids_zOS
+        t.column :five, :text, :default => "hello" unless mysql
       end
 
       columns = Person.connection.columns(:testings)
@@ -297,65 +295,18 @@ if ActiveRecord::Base.connection.supports_migrations?
       two = columns.detect { |c| c.name == "two" }
       three = columns.detect { |c| c.name == "three" }
       four = columns.detect { |c| c.name == "four" }
-      five = columns.detect { |c| c.name == "five" } unless mysql || ibm_ids_zOS
+      five = columns.detect { |c| c.name == "five" } unless mysql
 
       assert_equal "hello", one.default
       assert_equal true, two.default
       assert_equal false, three.default
       assert_equal 1, four.default
-      assert_equal "hello", five.default unless mysql || ibm_ids_zOS
+      assert_equal "hello", five.default unless mysql
 
     ensure
       Person.connection.drop_table :testings rescue nil
     end
 
-  if current_adapter?(:IBM_DBAdapter)
-    def test_no_limits_datatypes_IBM_DB
-      ibm_ids = ActiveRecord::Base.connection.servertype.class.name.include?('::IBM_IDS')
-      clasz = Class.new(ActiveRecord::Base)
-      clasz.table_name = 'test_no_limits_datatypes_IBM_DB'
-      assert_nothing_raised do
-        clasz.connection.create_table clasz.table_name do |t|
-          t.column "test_varchar",  :string,    :limit => 10
-          t.column "test_integer",  :integer,   :limit => 5
-          t.column "test_boolean",  :boolean,   :limit => 5
-          t.column "test_double",   :double,    :limit => 10
-          t.column "test_date",     :date,      :limit => 10
-          t.column "test_time",     :time,      :limit => 10
-          t.column "test_tstamp",   :timestamp, :limit => 10
-          t.column "test_xml",      :xml,       :limit => 10  unless ibm_ids
-          t.column "test_clob",     :text,      :limit => 10000
-          t.column "test_decfloat", :decfloat,  :limit => 100
-        end
-      end
-    ensure
-      clasz.connection.drop_table(clasz.table_name) rescue nil
-    end
-      
-    #Sexy migration test for column of type xml and char
-    def test_short_hand_migrations_for_ibm_db_datatypes
-      ibm_ids = ActiveRecord::Base.connection.servertype.class.name.include?('::IBM_IDS')
-      clasz = Class.new(ActiveRecord::Base)
-      clasz.table_name = 'test_short_hand_migrations'
-      assert_nothing_raised do
-        clasz.connection.create_table clasz.table_name do |t|
-          t.xml      :xml_col  unless ibm_ids
-          t.char     :char_col, :limit=>10
-          t.decfloat :dec_col, :precision=>16
-        end
-      end
-      assert_nothing_raised do
-        clasz.connection.change_table clasz.table_name do |t|
-          t.xml      :xml_col1  unless ibm_ids
-          t.char     :char_col1, :limit=>50
-          t.decfloat :dec_col1, :precision=>34
-        end
-      end
-    ensure
-      clasz.connection.drop_table(clasz.table_name) rescue nil
-    end
-  end
-  
     def test_create_table_with_limits
       assert_nothing_raised do
         Person.connection.create_table :testings do |t|
@@ -487,7 +438,7 @@ if ActiveRecord::Base.connection.supports_migrations?
 
     # Sybase, and SQLite3 will not allow you to add a NOT NULL
     # column to a table without a default value.
-    unless current_adapter?(:SybaseAdapter, :SQLiteAdapter, :IBM_DBAdapter)
+    unless current_adapter?(:SybaseAdapter, :SQLite3Adapter, :IBM_DBAdapter)
       def test_add_column_not_null_without_default
         Person.connection.create_table :testings do |t|
           t.column :foo, :string
@@ -609,7 +560,7 @@ if ActiveRecord::Base.connection.supports_migrations?
       assert_equal "I was born ....", bob.bio
       assert_equal 18, bob.age
 
-      # Test for 30 significent digits (beyond the 16 of float), 10 of them
+      # Test for 30 significant digits (beyond the 16 of float), 10 of them
       # after the decimal place.
 
       unless current_adapter?(:SQLite3Adapter)
@@ -742,17 +693,17 @@ if ActiveRecord::Base.connection.supports_migrations?
       end
     end
 
-    if (!current_adapter?(:IBM_DBAdapter) || @ibm_db_rename_supported)
+    if(!current_adapter?(:IBM_DBAdapter) || @ibm_db_rename_supported)
       def test_add_rename
         Person.delete_all
-  
+
         begin
           Person.connection.add_column "people", "girlfriend", :string
           Person.reset_column_information
           Person.create :girlfriend => 'bobette'
-  
+
           Person.connection.rename_column "people", "girlfriend", "exgirlfriend"
-    
+
           Person.reset_column_information
           bob = Person.find(:first)
 
@@ -763,7 +714,7 @@ if ActiveRecord::Base.connection.supports_migrations?
         end
 
       end
-  
+
       def test_rename_column_using_symbol_arguments
         begin
           names_before = Person.find(:all).map(&:first_name)
@@ -809,7 +760,7 @@ if ActiveRecord::Base.connection.supports_migrations?
         ActiveRecord::Base.connection.create_table(:hats) do |table|
           table.column :hat_name, :string, :default => nil
         end
-        exception = if current_adapter?(:PostgreSQLAdapter)
+        exception = if current_adapter?(:PostgreSQLAdapter, :OracleAdapter)
           ActiveRecord::StatementInvalid
         else
           ActiveRecord::ActiveRecordError
@@ -833,7 +784,7 @@ if ActiveRecord::Base.connection.supports_migrations?
       end
     end
 
-    unless (current_adapter?(:IBM_DBAdapter)) #Cannot alter a object when there is another object depending on it
+    unless current_adapter?(:IBM_DBAdapter)
       def test_rename_column_with_an_index
         ActiveRecord::Base.connection.create_table(:hats) do |table|
           table.column :hat_name, :string, :limit => 100
@@ -848,59 +799,62 @@ if ActiveRecord::Base.connection.supports_migrations?
       end
     end
 
-    def test_rename_column_with_an_index
+    def test_remove_column_with_index
       ActiveRecord::Base.connection.create_table(:hats) do |table|
         table.column :hat_name, :string, :limit => 100
         table.column :hat_size, :integer
       end
-      Person.connection.add_index :hats, :hat_name
-      assert_nothing_raised do
-        Person.connection.rename_column "hats", "hat_name", "name"
-      end
+      ActiveRecord::Base.connection.add_index "hats", "hat_size"
+
+      assert_nothing_raised { Person.connection.remove_column("hats", "hat_size") }
     ensure
       ActiveRecord::Base.connection.drop_table(:hats)
     end
 
-    def test_remove_column_with_index
+    def test_remove_column_with_multi_column_index
       ActiveRecord::Base.connection.create_table(:hats) do |table|
         table.column :hat_name, :string, :limit => 100
         table.column :hat_size, :integer
+        table.column :hat_style, :string, :limit => 100
       end
-      ActiveRecord::Base.connection.add_index "hats", "hat_size"
+      ActiveRecord::Base.connection.add_index "hats", ["hat_style", "hat_size"], :unique => true
 
       assert_nothing_raised { Person.connection.remove_column("hats", "hat_size") }
     ensure
       ActiveRecord::Base.connection.drop_table(:hats)
     end
 
-    unless (current_adapter?(:IBM_DBAdapter)) #Cannot alter a object when there is another object depending on it
-      def test_remove_column_with_multi_column_index
-        ActiveRecord::Base.connection.create_table(:hats) do |table|
-          table.column :hat_name, :string, :limit => 100
-          table.column :hat_size, :integer
-          table.column :hat_style, :string, :limit => 100
-        end
-        ActiveRecord::Base.connection.add_index "hats", ["hat_style", "hat_size"], :unique => true
-
-        assert_nothing_raised { Person.connection.remove_column("hats", "hat_size") }
-      ensure
-        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
 
-    unless current_adapter?(:IBM_DBAdapter) #incompatible types changes
-      def test_change_type_of_not_null_column
-        assert_nothing_raised do
+    def test_change_type_of_not_null_column
+      assert_nothing_raised do
+        unless current_adapter?(:IBM_DBAdapter)
           Topic.connection.change_column "topics", "written_on", :datetime, :null => false
-          Topic.reset_column_information
+        else
+          Topic.connection.change_column_null "topics", "written_on", false
+        end
+        Topic.reset_column_information
 
+        unless current_adapter?(:IBM_DBAdapter)
           Topic.connection.change_column "topics", "written_on", :datetime, :null => false
-          Topic.reset_column_information
+        else
+          Topic.connection.change_column_null "topics", "written_on", false
         end
+        Topic.reset_column_information
+
+        unless current_adapter?(:IBM_DBAdapter)
+          Topic.connection.change_column "topics", "written_on", :datetime, :null => true
+        else
+          Topic.connection.change_column_null "topics", "written_on", true
+        end
+
+        Topic.reset_column_information
       end
-    end 
+    end
 
-    if current_adapter?(:SQLiteAdapter)
+    if current_adapter?(:SQLite3Adapter)
       def test_rename_table_for_sqlite_should_work_with_reserved_words
         begin
           assert_nothing_raised do
@@ -952,14 +906,20 @@ if ActiveRecord::Base.connection.supports_migrations?
       Person.connection.add_column "people", "funny", :boolean
       Person.reset_column_information
       assert Person.columns_hash["funny"].null, "Column 'funny' must initially allow nulls"
-      unless current_adapter?(:IBM_DBAdapter) # incompatible types changes  
+	  unless current_adapter?(:IBM_DBAdapter)
         Person.connection.change_column "people", "funny", :boolean, :null => false, :default => true
+      else
+        Person.connection.change_column_null "people", "funny",false
+      end
         Person.reset_column_information
         assert !Person.columns_hash["funny"].null, "Column 'funny' must *not* allow nulls at this point"
+      unless current_adapter?(:IBM_DBAdapter)
         Person.connection.change_column "people", "funny", :boolean, :null => true
-        Person.reset_column_information
-        assert Person.columns_hash["funny"].null, "Column 'funny' must allow nulls again at this point"
-      end 
+      else
+        Person.connection.change_column_null "people", "funny",true
+      end
+      Person.reset_column_information
+      assert Person.columns_hash["funny"].null, "Column 'funny' must allow nulls again at this point"
     end
 
     def test_rename_table_with_an_index
@@ -985,39 +945,44 @@ if ActiveRecord::Base.connection.supports_migrations?
       end
     end
 
-  unless current_adapter?(:IBM_DBAdapter) # incompatible types changes
-    def test_change_column
-      Person.connection.add_column 'people', 'age', :integer
-      label = "test_change_column Columns"
-      old_columns = Person.connection.columns(Person.table_name, label)
-      assert old_columns.find { |c| c.name == 'age' and c.type == :integer }
+	unless current_adapter?(:IBM_DBAdapter)
+      # Cannot convert from type integer to varchar.
+      # Safe to not run this test as add_column will be covered in other test cases
+      def test_change_column
+        Person.connection.add_column 'people', 'age', :integer
+        label = "test_change_column Columns"
+        old_columns = Person.connection.columns(Person.table_name, label)
+        assert old_columns.find { |c| c.name == 'age' and c.type == :integer }
 
-      assert_nothing_raised { Person.connection.change_column "people", "age", :string }
+        assert_nothing_raised { Person.connection.change_column "people", "age", :string }
 
-      new_columns = Person.connection.columns(Person.table_name, label)
-      assert_nil new_columns.find { |c| c.name == 'age' and c.type == :integer }
-      assert new_columns.find { |c| c.name == 'age' and c.type == :string }
+        new_columns = Person.connection.columns(Person.table_name, label)
+        assert_nil new_columns.find { |c| c.name == 'age' and c.type == :integer }
+        assert new_columns.find { |c| c.name == 'age' and c.type == :string }
 
-      old_columns = Topic.connection.columns(Topic.table_name, label)
-      assert old_columns.find { |c| c.name == 'approved' and c.type == :boolean and c.default == true }
-      assert_nothing_raised { Topic.connection.change_column :topics, :approved, :boolean, :default => false }
-      new_columns = Topic.connection.columns(Topic.table_name, label)
-      assert_nil new_columns.find { |c| c.name == 'approved' and c.type == :boolean and c.default == true }
-      assert new_columns.find { |c| c.name == 'approved' and c.type == :boolean and c.default == false }
-      assert_nothing_raised { Topic.connection.change_column :topics, :approved, :boolean, :default => true }
+        old_columns = Topic.connection.columns(Topic.table_name, label)
+        assert old_columns.find { |c| c.name == 'approved' and c.type == :boolean and c.default == true }
+        assert_nothing_raised { Topic.connection.change_column :topics, :approved, :boolean, :default => false }
+        new_columns = Topic.connection.columns(Topic.table_name, label)
+        assert_nil new_columns.find { |c| c.name == 'approved' and c.type == :boolean and c.default == true }
+        assert new_columns.find { |c| c.name == 'approved' and c.type == :boolean and c.default == false }
+        assert_nothing_raised { Topic.connection.change_column :topics, :approved, :boolean, :default => true }
+      end
     end
-  end
-  
+
     def test_change_column_with_nil_default
       Person.connection.add_column "people", "contributor", :boolean, :default => true
       Person.reset_column_information
       assert Person.new.contributor?
-      unless current_adapter?(:IBM_DBAdapter) # incompatible types changes
+
+      unless current_adapter?(:IBM_DBAdapter)
         assert_nothing_raised { Person.connection.change_column "people", "contributor", :boolean, :default => nil }
-        Person.reset_column_information
-        assert !Person.new.contributor?
-        assert_nil Person.new.contributor
-      end 
+      else
+        assert_nothing_raised { Person.connection.change_column_default "people", "contributor", nil }
+      end
+      Person.reset_column_information
+      assert !Person.new.contributor?
+      assert_nil Person.new.contributor
     ensure
       Person.connection.remove_column("people", "contributor") rescue nil
     end
@@ -1026,11 +991,14 @@ if ActiveRecord::Base.connection.supports_migrations?
       Person.connection.add_column "people", "administrator", :boolean, :default => true
       Person.reset_column_information
       assert Person.new.administrator?
-      unless current_adapter?(:IBM_DBAdapter) # incompatible types changes
+
+      unless current_adapter?(:IBM_DBAdapter)
         assert_nothing_raised { Person.connection.change_column "people", "administrator", :boolean, :default => false }
-        Person.reset_column_information
-        assert !Person.new.administrator?
-      end 
+      else
+        assert_nothing_raised { Person.connection.change_column_default "people", "administrator", false }
+      end
+      Person.reset_column_information
+      assert !Person.new.administrator?
     ensure
       Person.connection.remove_column("people", "administrator") rescue nil
     end
@@ -1043,10 +1011,11 @@ if ActiveRecord::Base.connection.supports_migrations?
 
     def test_change_column_quotes_column_names
       Person.connection.create_table :testings do |t|
-        if current_adapter?(:IBM_DBAdapter)
-          t.column :select, :string, :limit => 5
-        else
+        unless current_adapter?(:IBM_DBAdapter)
           t.column :select, :string
+        else
+          # If no limit specified by default column of length 255 is created, which later cannot be scaled down to 10
+          t.column :select, :string, :limit => 5
         end
       end
 
@@ -1087,16 +1056,16 @@ if ActiveRecord::Base.connection.supports_migrations?
       assert_equal false, person_klass.columns_hash["wealth"].null
 
       # rename column to see that column doesn't lose its not null and/or default definition
-      if (!current_adapter?(:IBM_DBAdapter) || @ibm_db_rename_supported) 
+      if (!current_adapter?(:IBM_DBAdapter) || @ibm_db_rename_supported)
         person_klass.connection.rename_column "testings", "wealth", "money"
         person_klass.reset_column_information
         assert_nil person_klass.columns_hash["wealth"]
         assert_equal 100, person_klass.columns_hash["money"].default
         assert_equal false, person_klass.columns_hash["money"].null
-      end 
+      end
 
       # change column
-      unless (current_adapter?(:IBM_DBAdapter) && !@ibm_db_rename_supported)
+      unless current_adapter?(:IBM_DBAdapter)
         person_klass.connection.change_column "testings", "money", :integer, :null => false, :default => 1000
         person_klass.reset_column_information
         assert_equal 1000, person_klass.columns_hash["money"].default
@@ -1106,10 +1075,10 @@ if ActiveRecord::Base.connection.supports_migrations?
         person_klass.reset_column_information
         assert_equal 1000, person_klass.columns_hash["wealth"].default
         assert_equal false, person_klass.columns_hash["wealth"].null
-      end   
+      end
 
       # change column, make it nullable and clear default
-      unless (current_adapter?(:IBM_DBAdapter) && !@ibm_db_rename_supported)
+      unless current_adapter?(:IBM_DBAdapter)
         person_klass.connection.change_column "testings", "money", :integer, :null => true, :default => nil
         person_klass.reset_column_information
         assert_nil person_klass.columns_hash["money"].default
@@ -1119,10 +1088,10 @@ if ActiveRecord::Base.connection.supports_migrations?
         person_klass.reset_column_information
         assert_nil person_klass.columns_hash["wealth"].default
         assert_equal true, person_klass.columns_hash["wealth"].null
-      end   
+      end
 
       # change_column_null, make it not nullable and set null values to a default value
-      unless (current_adapter?(:IBM_DBAdapter) && !@ibm_db_rename_supported)
+      unless current_adapter?(:IBM_DBAdapter)
         person_klass.connection.execute('UPDATE testings SET money = NULL')
         person_klass.connection.change_column_null "testings", "money", false, 2000
         person_klass.reset_column_information
@@ -1131,12 +1100,15 @@ if ActiveRecord::Base.connection.supports_migrations?
         assert_equal [2000], Person.connection.select_values("SELECT money FROM testings").map { |s| s.to_i }.sort
       else
         # Trying to set the value of the column wealth to NULL and 
-        # in the next statement a not null constraint is being applied which is wrong.
-        #person_klass.connection.execute('UPDATE testings SET wealth = NULL')
+        # in the next statement a not null constraint is being applied which is wrong 
+        #person_klass.connection.execute('UPDATE testings SET money = NULL')
         person_klass.connection.change_column_null "testings", "wealth", false, 2000
         person_klass.reset_column_information
+        #assert_nil person_klass.columns_hash["wealth"].default #Setting default to 2000 and expecting nil is nor correct
+        assert_not_nil person_klass.columns_hash["wealth"].default
         assert_equal false, person_klass.columns_hash["wealth"].null
-        assert_equal 2000, person_klass.columns_hash["wealth"].default
+        #Changing default does not change the already inserted value. Hence expecting 2000 is wrong.
+        assert_equal [99], Person.connection.select_values("SELECT wealth FROM testings").map { |s| s.to_i }.sort
       end
     ensure
       Person.connection.drop_table :testings rescue nil
@@ -1187,6 +1159,18 @@ if ActiveRecord::Base.connection.supports_migrations?
       Person.connection.drop_table :testings rescue nil
     end
 
+    def test_column_exists_on_table_with_no_options_parameter_supplied
+      Person.connection.create_table :testings do |t|
+        t.string :foo
+      end
+      Person.connection.change_table :testings do |t|
+        assert t.column_exists?(:foo)
+        assert !(t.column_exists?(:bar))
+      end
+    ensure
+      Person.connection.drop_table :testings rescue nil
+    end
+
     def test_add_table
       assert !Reminder.table_exists?
 
@@ -1224,17 +1208,17 @@ if ActiveRecord::Base.connection.supports_migrations?
 
       # TODO: set world_population >= 2**62 to cover 64-bit platforms and test
       # is_a?(Bignum)
-      unless current_adapter?(:IBM_DBAdapter) # incompatible types retrieved
+      unless current_adapter?(:IBM_DBAdapter)
         assert_kind_of Integer, b.world_population
       else
         assert_kind_of BigDecimal, b.world_population
-      end   
+      end
       assert_equal 6000000000, b.world_population
-      unless current_adapter?(:IBM_DBAdapter) # incompatible types retrieved
+      unless current_adapter?(:IBM_DBAdapter)
         assert_kind_of Fixnum, b.my_house_population
       else
         assert_kind_of BigDecimal, b.my_house_population
-      end  
+      end
       assert_equal 3, b.my_house_population
       assert_kind_of BigDecimal, b.bank_balance
       assert_equal BigDecimal("1586.43"), b.bank_balance
@@ -1254,17 +1238,17 @@ if ActiveRecord::Base.connection.supports_migrations?
         # so this happens there too
         assert_kind_of BigDecimal, b.value_of_e
         assert_equal BigDecimal("2.7182818284590452353602875"), b.value_of_e
-      elsif current_adapter?(:SQLiteAdapter)
+      elsif current_adapter?(:SQLite3Adapter)
         # - SQLite3 stores a float, in violation of SQL
         assert_kind_of BigDecimal, b.value_of_e
         assert_in_delta BigDecimal("2.71828182845905"), b.value_of_e, 0.00000000000001
       else
         # - SQL standard is an integer
-      unless current_adapter?(:IBM_DBAdapter) # incompatible types retrieved
-        assert_kind_of Fixnum, b.value_of_e
-      else
-        assert_kind_of BigDecimal, b.value_of_e
-      end 
+        unless current_adapter?(:IBM_DBAdapter)
+          assert_kind_of Fixnum, b.value_of_e
+        else
+          assert_kind_of BigDecimal, b.value_of_e
+        end
         assert_equal 2, b.value_of_e
       end
 
@@ -1292,6 +1276,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?
@@ -1359,51 +1381,56 @@ if ActiveRecord::Base.connection.supports_migrations?
     def test_finds_migrations
       migrations = ActiveRecord::Migrator.new(:up, MIGRATIONS_ROOT + "/valid").migrations
 
-      [[1, 'PeopleHaveLastNames'], [2, 'WeNeedReminders'], [3, 'InnocentJointable']].each_with_index do |pair, i|
+      [[1, 'ValidPeopleHaveLastNames'], [2, 'WeNeedReminders'], [3, 'InnocentJointable']].each_with_index do |pair, i|
         assert_equal migrations[i].version, pair.first
         assert_equal migrations[i].name, pair.last
       end
     end
 
+    def test_finds_migrations_from_two_directories
+      directories = [MIGRATIONS_ROOT + '/valid_with_timestamps', MIGRATIONS_ROOT + '/to_copy_with_timestamps']
+      migrations = ActiveRecord::Migrator.new(:up, directories).migrations
+
+      [[20090101010101, "PeopleHaveHobbies"],
+       [20090101010202, "PeopleHaveDescriptions"],
+       [20100101010101, "ValidWithTimestampsPeopleHaveLastNames"],
+       [20100201010101, "ValidWithTimestampsWeNeedReminders"],
+       [20100301010101, "ValidWithTimestampsInnocentJointable"]].each_with_index do |pair, i|
+        assert_equal pair.first, migrations[i].version
+        assert_equal pair.last, migrations[i].name
+      end
+    end
+
     def test_finds_pending_migrations
       ActiveRecord::Migrator.up(MIGRATIONS_ROOT + "/interleaved/pass_2", 1)
       migrations = ActiveRecord::Migrator.new(:up, MIGRATIONS_ROOT + "/interleaved/pass_2").pending_migrations
 
       assert_equal 1, migrations.size
       assert_equal migrations[0].version, 3
-      assert_equal migrations[0].name, 'InnocentJointable'
+      assert_equal migrations[0].name, 'InterleavedInnocentJointable'
     end
 
     def test_relative_migrations
-      $".delete_if do |fname|
-        fname == (MIGRATIONS_ROOT + "/valid/1_people_have_last_names.rb")
-      end
-      Object.send(:remove_const, :PeopleHaveLastNames)
-
-      Dir.chdir(MIGRATIONS_ROOT) do
+      list = Dir.chdir(MIGRATIONS_ROOT) do
         ActiveRecord::Migrator.up("valid/", 1)
       end
 
-      assert defined?(PeopleHaveLastNames)
+      migration_proxy = list.find { |item|
+        item.name == 'ValidPeopleHaveLastNames'
+      }
+      assert migration_proxy, 'should find pending migration'
     end
 
     def test_only_loads_pending_migrations
       # migrate up to 1
       ActiveRecord::Migrator.up(MIGRATIONS_ROOT + "/valid", 1)
 
-      # now unload the migrations that have been defined
-      Object.send(:remove_const, :PeopleHaveLastNames)
-
-      ActiveRecord::Migrator.migrate(MIGRATIONS_ROOT + "/valid", nil)
-
-      assert !defined? PeopleHaveLastNames
-
-      %w(WeNeedReminders, InnocentJointable).each do |migration|
-        assert defined? migration
-      end
+      proxies = ActiveRecord::Migrator.migrate(MIGRATIONS_ROOT + "/valid", nil)
 
-    ensure
-      load(MIGRATIONS_ROOT + "/valid/1_people_have_last_names.rb")
+      names = proxies.map(&:name)
+      assert !names.include?('ValidPeopleHaveLastNames')
+      assert names.include?('WeNeedReminders')
+      assert names.include?('InnocentJointable')
     end
 
     def test_target_version_zero_should_run_only_once
@@ -1413,16 +1440,9 @@ if ActiveRecord::Base.connection.supports_migrations?
       # migrate down to 0
       ActiveRecord::Migrator.migrate(MIGRATIONS_ROOT + "/valid", 0)
 
-      # now unload the migrations that have been defined
-      PeopleHaveLastNames.unloadable
-      ActiveSupport::Dependencies.remove_unloadable_constants!
-
       # migrate down to 0 again
-      ActiveRecord::Migrator.migrate(MIGRATIONS_ROOT + "/valid", 0)
-
-      assert !defined? PeopleHaveLastNames
-    ensure
-      load(MIGRATIONS_ROOT + "/valid/1_people_have_last_names.rb")
+      proxies = ActiveRecord::Migrator.migrate(MIGRATIONS_ROOT + "/valid", 0)
+      assert_equal [], proxies
     end
 
     def test_migrator_db_has_no_schema_migrations_table
@@ -1439,20 +1459,20 @@ if ActiveRecord::Base.connection.supports_migrations?
 
     def test_migrator_verbosity
       ActiveRecord::Migrator.up(MIGRATIONS_ROOT + "/valid", 1)
-      assert PeopleHaveLastNames.message_count > 0
-      PeopleHaveLastNames.message_count = 0
+      assert_not_equal 0, ActiveRecord::Migration.message_count
+      ActiveRecord::Migration.message_count = 0
 
       ActiveRecord::Migrator.down(MIGRATIONS_ROOT + "/valid", 0)
-      assert PeopleHaveLastNames.message_count > 0
-      PeopleHaveLastNames.message_count = 0
+      assert_not_equal 0, ActiveRecord::Migration.message_count
+      ActiveRecord::Migration.message_count = 0
     end
 
     def test_migrator_verbosity_off
-      PeopleHaveLastNames.verbose = false
+      ActiveRecord::Migration.verbose = false
       ActiveRecord::Migrator.up(MIGRATIONS_ROOT + "/valid", 1)
-      assert PeopleHaveLastNames.message_count.zero?
+      assert_equal 0, ActiveRecord::Migration.message_count
       ActiveRecord::Migrator.down(MIGRATIONS_ROOT + "/valid", 0)
-      assert PeopleHaveLastNames.message_count.zero?
+      assert_equal 0, ActiveRecord::Migration.message_count
     end
 
     def test_migrator_going_down_due_to_version_target
@@ -1715,13 +1735,23 @@ if ActiveRecord::Base.connection.supports_migrations?
       end
     end
 
-    if current_adapter?(:PostgreSQLAdapter)
+    if current_adapter?(:PostgreSQLAdapter) || current_adapter?(:SQLite3Adapter) || current_adapter?(:MysqlAdapter) || current_adapter?(:Mysql2Adapter) || current_adapter?(:IBM_DBAdapter)
       def test_xml_creates_xml_column
+        type = (current_adapter?(:PostgreSQLAdapter) || current_adapter?(:IBM_DBAdapter)) ? 'xml' : :text
+
         with_new_table do |t|
-          t.expects(:column).with(:data, 'xml', {})
+          t.expects(:column).with(:data, type, {})
           t.xml :data
         end
       end
+    else
+      def test_xml_creates_xml_column
+        with_new_table do |t|
+          assert_raises(NotImplementedError) do
+            t.xml :data
+          end
+        end
+      end
     end
 
     protected
@@ -1736,10 +1766,6 @@ if ActiveRecord::Base.connection.supports_migrations?
   end # SexyMigrationsTest
 
   class MigrationLoggerTest < ActiveRecord::TestCase
-    def setup
-      Object.send(:remove_const, :InnocentJointable)
-    end
-
     def test_migration_should_be_run_without_logger
       previous_logger = ActiveRecord::Base.logger
       ActiveRecord::Base.logger = nil
@@ -1752,10 +1778,6 @@ if ActiveRecord::Base.connection.supports_migrations?
   end
 
   class InterleavedMigrationsTest < ActiveRecord::TestCase
-    def setup
-      Object.send(:remove_const, :PeopleHaveLastNames)
-    end
-
     def test_migrator_interleaved_migrations
       ActiveRecord::Migrator.up(MIGRATIONS_ROOT + "/interleaved/pass_1")
 
@@ -1766,10 +1788,12 @@ if ActiveRecord::Base.connection.supports_migrations?
       Person.reset_column_information
       assert Person.column_methods_hash.include?(:last_name)
 
-      Object.send(:remove_const, :PeopleHaveLastNames)
-      Object.send(:remove_const, :InnocentJointable)
       assert_nothing_raised do
-        ActiveRecord::Migrator.down(MIGRATIONS_ROOT + "/interleaved/pass_3")
+        proxies = ActiveRecord::Migrator.down(
+          MIGRATIONS_ROOT + "/interleaved/pass_3")
+        names = proxies.map(&:name)
+        assert names.include?('InterleavedPeopleHaveLastNames')
+        assert names.include?('InterleavedInnocentJointable')
       end
     end
   end
@@ -2010,5 +2034,307 @@ if ActiveRecord::Base.connection.supports_migrations?
       end
     end
   end
-end
 
+  if ActiveRecord::Base.connection.supports_bulk_alter?
+    class BulkAlterTableMigrationsTest < ActiveRecord::TestCase
+      def setup
+        @connection = Person.connection
+        @connection.create_table(:delete_me, :force => true) {|t| }
+      end
+
+      def teardown
+        Person.connection.drop_table(:delete_me) rescue nil
+      end
+
+      def test_adding_multiple_columns
+        assert_queries(1) do
+          with_bulk_change_table do |t|
+            t.column :name, :string
+            t.string :qualification, :experience
+            t.integer :age, :default => 0
+            t.date :birthdate
+            t.timestamps
+          end
+        end
+
+        assert_equal 8, columns.size
+        [:name, :qualification, :experience].each {|s| assert_equal :string, column(s).type }
+        assert_equal 0, column(:age).default
+      end
+
+      def test_removing_columns
+        with_bulk_change_table do |t|
+          t.string :qualification, :experience
+        end
+
+        [:qualification, :experience].each {|c| assert column(c) }
+
+        assert_queries(1) do
+          with_bulk_change_table do |t|
+            t.remove :qualification, :experience
+            t.string :qualification_experience
+          end
+        end
+
+        [:qualification, :experience].each {|c| assert ! column(c) }
+        assert column(:qualification_experience)
+      end
+
+      def test_adding_indexes
+        with_bulk_change_table do |t|
+          t.string :username
+          t.string :name
+          t.integer :age
+        end
+
+        # Adding an index fires a query every time to check if an index already exists or not
+        assert_queries(3) do
+          with_bulk_change_table do |t|
+            t.index :username, :unique => true, :name => :awesome_username_index
+            t.index [:name, :age]
+          end
+        end
+
+        assert_equal 2, indexes.size
+
+        name_age_index = index(:index_delete_me_on_name_and_age)
+        assert_equal ['name', 'age'].sort, name_age_index.columns.sort
+        assert ! name_age_index.unique
+
+        assert index(:awesome_username_index).unique
+      end
+
+      def test_removing_index
+        with_bulk_change_table do |t|
+          t.string :name
+          t.index :name
+        end
+
+        assert index(:index_delete_me_on_name)
+
+        assert_queries(3) do
+          with_bulk_change_table do |t|
+            t.remove_index :name
+            t.index :name, :name => :new_name_index, :unique => true
+          end
+        end
+
+        assert ! index(:index_delete_me_on_name)
+
+        new_name_index = index(:new_name_index)
+        assert new_name_index.unique
+      end
+
+      def test_changing_columns
+        with_bulk_change_table do |t|
+          t.string :name
+          t.date :birthdate
+        end
+
+        assert ! column(:name).default
+        assert_equal :date, column(:birthdate).type
+
+        # One query for columns (delete_me table)
+        # One query for primary key (delete_me table)
+        # One query to do the bulk change
+        assert_queries(3) do
+          with_bulk_change_table do |t|
+            t.change :name, :string, :default => 'NONAME'
+            t.change :birthdate, :datetime
+          end
+        end
+
+        assert_equal 'NONAME', column(:name).default
+        assert_equal :datetime, column(:birthdate).type
+      end
+
+      protected
+
+      def with_bulk_change_table
+        # Reset columns/indexes cache as we're changing the table
+        @columns = @indexes = nil
+
+        Person.connection.change_table(:delete_me, :bulk => true) do |t|
+          yield t
+        end
+      end
+
+      def column(name)
+        columns.detect {|c| c.name == name.to_s }
+      end
+
+      def columns
+        @columns ||= Person.connection.columns('delete_me')
+      end
+
+      def index(name)
+        indexes.detect {|i| i.name == name.to_s }
+      end
+
+      def indexes
+        @indexes ||= Person.connection.indexes('delete_me')
+      end
+    end # AlterTableMigrationsTest
+
+  end
+
+  class CopyMigrationsTest < ActiveRecord::TestCase
+    def setup
+    end
+
+    def clear
+      ActiveRecord::Base.timestamped_migrations = true
+      to_delete = Dir[@migrations_path + "/*.rb"] - @existing_migrations
+      File.delete(*to_delete)
+    end
+
+    def test_copying_migrations_without_timestamps
+      ActiveRecord::Base.timestamped_migrations = false
+      @migrations_path = MIGRATIONS_ROOT + "/valid"
+      @existing_migrations = Dir[@migrations_path + "/*.rb"]
+
+      copied = ActiveRecord::Migration.copy(@migrations_path, {:bukkits => MIGRATIONS_ROOT + "/to_copy"})
+      assert File.exists?(@migrations_path + "/4_people_have_hobbies.rb")
+      assert File.exists?(@migrations_path + "/5_people_have_descriptions.rb")
+      assert_equal [@migrations_path + "/4_people_have_hobbies.rb", @migrations_path + "/5_people_have_descriptions.rb"], copied.map(&:filename)
+
+      files_count = Dir[@migrations_path + "/*.rb"].length
+      copied = ActiveRecord::Migration.copy(@migrations_path, {:bukkits => MIGRATIONS_ROOT + "/to_copy"})
+      assert_equal files_count, Dir[@migrations_path + "/*.rb"].length
+      assert copied.empty?
+    ensure
+      clear
+    end
+
+    def test_copying_migrations_without_timestamps_from_2_sources
+      ActiveRecord::Base.timestamped_migrations = false
+      @migrations_path = MIGRATIONS_ROOT + "/valid"
+      @existing_migrations = Dir[@migrations_path + "/*.rb"]
+
+      sources = ActiveSupport::OrderedHash.new
+      sources[:bukkits] = MIGRATIONS_ROOT + "/to_copy"
+      sources[:omg] = MIGRATIONS_ROOT + "/to_copy2"
+      ActiveRecord::Migration.copy(@migrations_path, sources)
+      assert File.exists?(@migrations_path + "/4_people_have_hobbies.rb")
+      assert File.exists?(@migrations_path + "/5_people_have_descriptions.rb")
+      assert File.exists?(@migrations_path + "/6_create_articles.rb")
+      assert File.exists?(@migrations_path + "/7_create_comments.rb")
+
+      files_count = Dir[@migrations_path + "/*.rb"].length
+      ActiveRecord::Migration.copy(@migrations_path, sources)
+      assert_equal files_count, Dir[@migrations_path + "/*.rb"].length
+    ensure
+      clear
+    end
+
+    def test_copying_migrations_with_timestamps
+      @migrations_path = MIGRATIONS_ROOT + "/valid_with_timestamps"
+      @existing_migrations = Dir[@migrations_path + "/*.rb"]
+
+      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")
+        expected = [@migrations_path + "/20100726101010_people_have_hobbies.rb",
+                    @migrations_path + "/20100726101011_people_have_descriptions.rb"]
+        assert_equal expected, copied.map(&:filename)
+
+        files_count = Dir[@migrations_path + "/*.rb"].length
+        copied = ActiveRecord::Migration.copy(@migrations_path, {:bukkits => MIGRATIONS_ROOT + "/to_copy_with_timestamps"})
+        assert_equal files_count, Dir[@migrations_path + "/*.rb"].length
+        assert copied.empty?
+      end
+    ensure
+      clear
+    end
+
+    def test_copying_migrations_with_timestamps_from_2_sources
+      @migrations_path = MIGRATIONS_ROOT + "/valid_with_timestamps"
+      @existing_migrations = Dir[@migrations_path + "/*.rb"]
+
+      sources = ActiveSupport::OrderedHash.new
+      sources[:bukkits] = MIGRATIONS_ROOT + "/to_copy_with_timestamps"
+      sources[:omg]     = MIGRATIONS_ROOT + "/to_copy_with_timestamps2"
+
+      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")
+        assert File.exists?(@migrations_path + "/20100726101012_create_articles.rb")
+        assert File.exists?(@migrations_path + "/20100726101013_create_comments.rb")
+        assert_equal 4, copied.length
+
+        files_count = Dir[@migrations_path + "/*.rb"].length
+        ActiveRecord::Migration.copy(@migrations_path, sources)
+        assert_equal files_count, Dir[@migrations_path + "/*.rb"].length
+      end
+    ensure
+      clear
+    end
+
+    def test_copying_migrations_with_timestamps_to_destination_with_timestamps_in_future
+      @migrations_path = MIGRATIONS_ROOT + "/valid_with_timestamps"
+      @existing_migrations = Dir[@migrations_path + "/*.rb"]
+
+      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")
+
+        files_count = Dir[@migrations_path + "/*.rb"].length
+        copied = ActiveRecord::Migration.copy(@migrations_path, {:bukkits => MIGRATIONS_ROOT + "/to_copy_with_timestamps"})
+        assert_equal files_count, Dir[@migrations_path + "/*.rb"].length
+        assert copied.empty?
+      end
+    ensure
+      clear
+    end
+
+    def test_skipping_migrations
+      @migrations_path = MIGRATIONS_ROOT + "/valid_with_timestamps"
+      @existing_migrations = Dir[@migrations_path + "/*.rb"]
+
+      sources = ActiveSupport::OrderedHash.new
+      sources[:bukkits] = sources[:omg] = MIGRATIONS_ROOT + "/to_copy_with_timestamps"
+
+      skipped = []
+      on_skip = Proc.new { |name, migration| skipped << "#{name} #{migration.name}" }
+      copied = ActiveRecord::Migration.copy(@migrations_path, sources, :on_skip => on_skip)
+      assert_equal 2, copied.length
+
+      assert_equal 2, skipped.length
+      assert_equal ["bukkits PeopleHaveHobbies", "bukkits PeopleHaveDescriptions"], skipped
+    ensure
+      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(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
+    end
+  end
+end