ibm_db 3.0.5 → 5.0.5

data/test/cases/integration_test.rb

@@ -1,139 +1,155 @@
-# encoding: utf-8
-
-require 'cases/helper'
-require 'models/company'
-require 'models/developer'
-require 'models/computer'
-require 'models/owner'
-require 'models/pet'
-
-class IntegrationTest < ActiveRecord::TestCase
-  fixtures :companies, :developers, :owners, :pets
-
-  def test_to_param_should_return_string
-    assert_kind_of String, Client.first.to_param
-  end
-
-  def test_to_param_returns_nil_if_not_persisted
-    client = Client.new
-    assert_equal nil, client.to_param
-  end
-
-  def test_to_param_returns_id_if_not_persisted_but_id_is_set
-    client = Client.new
-    client.id = 1
-    assert_equal '1', client.to_param
-  end
-
-  def test_to_param_class_method
-    firm = Firm.find(4)
-    assert_equal '4-flamboyant-software', firm.to_param
-  end
-
-  def test_to_param_class_method_truncates
-    firm = Firm.find(4)
-    firm.name = 'a ' * 100
-    assert_equal '4-a-a-a-a-a-a-a-a-a', firm.to_param
-  end
-
-  def test_to_param_class_method_truncates_edge_case
-    firm = Firm.find(4)
-    firm.name = 'David HeinemeierHansson'
-    assert_equal '4-david', firm.to_param
-  end
-
-  def test_to_param_class_method_squishes
-    firm = Firm.find(4)
-    firm.name = "ab \n" * 100
-    assert_equal '4-ab-ab-ab-ab-ab-ab', firm.to_param
-  end
-
-  def test_to_param_class_method_multibyte_character
-    firm = Firm.find(4)
-    firm.name = "戦場ヶ原 ひたぎ"
-    assert_equal '4', firm.to_param
-  end
-
-  def test_to_param_class_method_uses_default_if_blank
-    firm = Firm.find(4)
-    firm.name = nil
-    assert_equal '4', firm.to_param
-    firm.name = ' '
-    assert_equal '4', firm.to_param
-  end
-
-  def test_to_param_class_method_uses_default_if_not_persisted
-    firm = Firm.new(name: 'Fancy Shirts')
-    assert_equal nil, firm.to_param
-  end
-
-  def test_to_param_with_no_arguments
-    assert_equal 'Firm', Firm.to_param
-  end
-
-  def test_cache_key_for_existing_record_is_not_timezone_dependent
-    utc_key = Developer.first.cache_key
-
-    with_timezone_config zone: "EST" do
-      est_key = Developer.first.cache_key
-      assert_equal utc_key, est_key
-    end
-  end
-
-  def test_cache_key_format_for_existing_record_with_updated_at
-    dev = Developer.first
-    assert_equal "developers/#{dev.id}-#{dev.updated_at.utc.to_s(:nsec)}", dev.cache_key
-  end
-
-  def test_cache_key_format_for_existing_record_with_updated_at_and_custom_cache_timestamp_format
-    dev = CachedDeveloper.first
-    assert_equal "cached_developers/#{dev.id}-#{dev.updated_at.utc.to_s(:number)}", dev.cache_key
-  end
-
-  def test_cache_key_changes_when_child_touched
-    owner = owners(:blackbeard)
-    pet   = pets(:parrot)
-
-    owner.update_column :updated_at, Time.current
-    key = owner.cache_key
-
-    assert pet.touch
-    assert_not_equal key, owner.reload.cache_key
-  end
-
-  def test_cache_key_format_for_existing_record_with_nil_updated_timestamps
-    dev = Developer.first
-    dev.update_columns(updated_at: nil, updated_on: nil)
-    assert_match(/\/#{dev.id}$/, dev.cache_key)
-  end
-
-  def test_cache_key_for_updated_on
-    dev = Developer.first
-    dev.updated_at = nil
-    assert_equal "developers/#{dev.id}-#{dev.updated_on.utc.to_s(:nsec)}", dev.cache_key
-  end
-
-  def test_cache_key_for_newer_updated_at
-    dev = Developer.first
-    dev.updated_at += 3600
-    assert_equal "developers/#{dev.id}-#{dev.updated_at.utc.to_s(:nsec)}", dev.cache_key
-  end
-
-  def test_cache_key_for_newer_updated_on
-    dev = Developer.first
-    dev.updated_on += 3600
-    assert_equal "developers/#{dev.id}-#{dev.updated_on.utc.to_s(:nsec)}", dev.cache_key
-  end
-
-  def test_cache_key_format_is_precise_enough
-    dev = Developer.first
-    key = dev.cache_key
-    dev.touch
-    assert_not_equal key, dev.cache_key
-  end
-
-  def test_named_timestamps_for_cache_key
-    owner = owners(:blackbeard)
-    assert_equal "owners/#{owner.id}-#{owner.happy_at.utc.to_s(:nsec)}", owner.cache_key(:updated_at, :happy_at)
-  end
-end
+
+require 'cases/helper'
+require 'models/company'
+require 'models/developer'
+require 'models/computer'
+require 'models/owner'
+require 'models/pet'
+
+class IntegrationTest < ActiveRecord::TestCase
+  fixtures :companies, :developers, :owners, :pets
+
+  def test_to_param_should_return_string
+    assert_kind_of String, Client.first.to_param
+  end
+
+  def test_to_param_returns_nil_if_not_persisted
+    client = Client.new
+    assert_equal nil, client.to_param
+  end
+
+  def test_to_param_returns_id_if_not_persisted_but_id_is_set
+    client = Client.new
+    client.id = 1
+    assert_equal '1', client.to_param
+  end
+
+  def test_to_param_class_method
+    firm = Firm.find(4)
+    assert_equal '4-flamboyant-software', firm.to_param
+  end
+
+  def test_to_param_class_method_truncates
+    firm = Firm.find(4)
+    firm.name = 'a ' * 100
+    assert_equal '4-a-a-a-a-a-a-a-a-a', firm.to_param
+  end
+
+  def test_to_param_class_method_truncates_edge_case
+    firm = Firm.find(4)
+    firm.name = 'David HeinemeierHansson'
+    assert_equal '4-david', firm.to_param
+  end
+
+  def test_to_param_class_method_squishes
+    firm = Firm.find(4)
+    firm.name = "ab \n" * 100
+    assert_equal '4-ab-ab-ab-ab-ab-ab', firm.to_param
+  end
+
+  def test_to_param_class_method_multibyte_character
+    firm = Firm.find(4)
+    firm.name = "戦場ヶ原 ひたぎ"
+    assert_equal '4', firm.to_param
+  end
+
+  def test_to_param_class_method_uses_default_if_blank
+    firm = Firm.find(4)
+    firm.name = nil
+    assert_equal '4', firm.to_param
+    firm.name = ' '
+    assert_equal '4', firm.to_param
+  end
+
+  def test_to_param_class_method_uses_default_if_not_persisted
+    firm = Firm.new(name: 'Fancy Shirts')
+    assert_equal nil, firm.to_param
+  end
+
+  def test_to_param_with_no_arguments
+    assert_equal 'Firm', Firm.to_param
+  end
+
+  def test_cache_key_for_existing_record_is_not_timezone_dependent
+    utc_key = Developer.first.cache_key
+
+    with_timezone_config zone: "EST" do
+      est_key = Developer.first.cache_key
+      assert_equal utc_key, est_key
+    end
+  end
+
+  def test_cache_key_format_for_existing_record_with_updated_at
+    dev = Developer.first
+    assert_equal "developers/#{dev.id}-#{dev.updated_at.utc.to_s(:usec)}", dev.cache_key
+  end
+
+  def test_cache_key_format_for_existing_record_with_updated_at_and_custom_cache_timestamp_format
+    dev = CachedDeveloper.first
+    assert_equal "cached_developers/#{dev.id}-#{dev.updated_at.utc.to_s(:number)}", dev.cache_key
+  end
+
+  def test_cache_key_changes_when_child_touched
+    owner = owners(:blackbeard)
+    pet   = pets(:parrot)
+
+    owner.update_column :updated_at, Time.current
+    key = owner.cache_key
+
+    travel(1.second) do
+      assert pet.touch
+    end
+    assert_not_equal key, owner.reload.cache_key
+  end
+
+  def test_cache_key_format_for_existing_record_with_nil_updated_timestamps
+    dev = Developer.first
+    dev.update_columns(updated_at: nil, updated_on: nil)
+    assert_match(/\/#{dev.id}$/, dev.cache_key)
+  end
+
+  def test_cache_key_for_updated_on
+    dev = Developer.first
+    dev.updated_at = nil
+    assert_equal "developers/#{dev.id}-#{dev.updated_on.utc.to_s(:usec)}", dev.cache_key
+  end
+
+  def test_cache_key_for_newer_updated_at
+    dev = Developer.first
+    dev.updated_at += 3600
+    assert_equal "developers/#{dev.id}-#{dev.updated_at.utc.to_s(:usec)}", dev.cache_key
+  end
+
+  def test_cache_key_for_newer_updated_on
+    dev = Developer.first
+    dev.updated_on += 3600
+    assert_equal "developers/#{dev.id}-#{dev.updated_on.utc.to_s(:usec)}", dev.cache_key
+  end
+
+  def test_cache_key_format_is_precise_enough
+    skip("Subsecond precision is not supported") unless subsecond_precision_supported?
+    dev = Developer.first
+    key = dev.cache_key
+    dev.touch
+    assert_not_equal key, dev.cache_key
+  end
+
+  def test_cache_key_format_is_not_too_precise
+    skip("Subsecond precision is not supported") unless subsecond_precision_supported?
+    dev = Developer.first
+    dev.touch
+    key = dev.cache_key
+    assert_equal key, dev.reload.cache_key
+  end
+
+  def test_named_timestamps_for_cache_key
+    owner = owners(:blackbeard)
+    assert_equal "owners/#{owner.id}-#{owner.happy_at.utc.to_s(:usec)}", owner.cache_key(:updated_at, :happy_at)
+  end
+
+  def test_cache_key_when_named_timestamp_is_nil
+    owner = owners(:blackbeard)
+    owner.happy_at = nil
+    assert_equal "owners/#{owner.id}", owner.cache_key(:happy_at)
+  end
+end

data/test/cases/invalid_connection_test.rb

@@ -1,22 +1,24 @@
-require "cases/helper"
-
-class TestAdapterWithInvalidConnection < ActiveRecord::TestCase
-  self.use_transactional_fixtures = false
-
-  class Bird < ActiveRecord::Base
-  end
-
-  def setup
-    # Can't just use current adapter; sqlite3 will create a database
-    # file on the fly.
-    Bird.establish_connection adapter: 'mysql', database: 'i_do_not_exist'
-  end
-
-  teardown do
-    Bird.remove_connection
-  end
-
-  test "inspect on Model class does not raise" do
-    assert_equal "#{Bird.name} (call '#{Bird.name}.connection' to establish a connection)", Bird.inspect
-  end
-end
+require "cases/helper"
+
+if current_adapter?(:Mysql2Adapter)
+class TestAdapterWithInvalidConnection < ActiveRecord::TestCase
+  self.use_transactional_tests = false
+
+  class Bird < ActiveRecord::Base
+  end
+
+  def setup
+    # Can't just use current adapter; sqlite3 will create a database
+    # file on the fly.
+    Bird.establish_connection adapter: 'mysql2', database: 'i_do_not_exist'
+  end
+
+  teardown do
+    Bird.remove_connection
+  end
+
+  test "inspect on Model class does not raise" do
+    assert_equal "#{Bird.name} (call '#{Bird.name}.connection' to establish a connection)", Bird.inspect
+  end
+end
+end

data/test/cases/invertible_migration_test.rb

@@ -1,295 +1,387 @@
-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 InvertibleRevertMigration < SilentMigration
-      def change
-        revert do
-          create_table("horses") do |t|
-            t.column :content, :text
-            t.column :remind_at, :datetime
-          end
-        end
-      end
-    end
-
-    class InvertibleByPartsMigration < SilentMigration
-      attr_writer :test
-      def change
-        create_table("new_horses") do |t|
-          t.column :breed, :string
-        end
-        reversible do |dir|
-          @test.yield :both
-          dir.up    { @test.yield :up }
-          dir.down  { @test.yield :down }
-        end
-        revert do
-          create_table("horses") do |t|
-            t.column :content, :text
-            t.column :remind_at, :datetime
-          end
-        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
-
-    class RemoveIndexMigration1 < SilentMigration
-      def self.up
-        create_table("horses") do |t|
-          t.column :name, :string
-          t.column :color, :string
-          t.index [:name, :color]
-        end
-      end
-    end
-
-    class RemoveIndexMigration2 < SilentMigration
-      def change
-        change_table("horses") do |t|
-          t.remove_index [:name, :color]
-        end
-      end
-    end
-
-    class LegacyMigration < ActiveRecord::Migration
-      def self.up
-        create_table("horses") do |t|
-          t.column :content, :text
-          t.column :remind_at, :datetime
-        end
-      end
-
-      def self.down
-        drop_table("horses")
-      end
-    end
-
-    class RevertWholeMigration < SilentMigration
-      def initialize(name = self.class.name, version = nil, migration)
-        @migration = migration
-        super(name, version)
-      end
-
-      def change
-        revert @migration
-      end
-    end
-
-    class NestedRevertWholeMigration < RevertWholeMigration
-      def change
-        revert { super }
-      end
-    end
-
-    class RevertNamedIndexMigration1 < SilentMigration
-      def change
-        create_table("horses") do |t|
-          t.column :content, :string
-          t.column :remind_at, :datetime
-        end
-        add_index :horses, :content
-      end
-    end
-
-    class RevertNamedIndexMigration2 < SilentMigration
-      def change
-        add_index :horses, :content, name: "horses_index_named"
-      end
-    end
-
-    setup do
-      @verbose_was, ActiveRecord::Migration.verbose = ActiveRecord::Migration.verbose, false
-    end
-
-    teardown do
-      %w[horses new_horses].each do |table|
-        if ActiveRecord::Base.connection.table_exists?(table)
-          ActiveRecord::Base.connection.drop_table(table)
-        end
-      end
-      ActiveRecord::Migration.verbose = @verbose_was
-    end
-
-    def test_no_reverse
-      migration = NonInvertibleMigration.new
-      migration.migrate(:up)
-      assert_raises(IrreversibleMigration) do
-        migration.migrate(:down)
-      end
-    end
-
-    def test_exception_on_removing_index_without_column_option
-      RemoveIndexMigration1.new.migrate(:up)
-      migration = RemoveIndexMigration2.new
-      migration.migrate(:up)
-
-      assert_raises(IrreversibleMigration) do
-        migration.migrate(:down)
-      end
-    end
-
-    def test_migrate_up
-      migration = InvertibleMigration.new
-      migration.migrate(:up)
-      assert migration.connection.table_exists?("horses"), "horses should exist"
-    end
-
-    def test_migrate_down
-      migration = InvertibleMigration.new
-      migration.migrate :up
-      migration.migrate :down
-      assert !migration.connection.table_exists?("horses")
-    end
-
-    def test_migrate_revert
-      migration = InvertibleMigration.new
-      revert = InvertibleRevertMigration.new
-      migration.migrate :up
-      revert.migrate :up
-      assert !migration.connection.table_exists?("horses")
-      revert.migrate :down
-      assert migration.connection.table_exists?("horses")
-      migration.migrate :down
-      assert !migration.connection.table_exists?("horses")
-    end
-
-    def test_migrate_revert_by_part
-      InvertibleMigration.new.migrate :up
-      received = []
-      migration = InvertibleByPartsMigration.new
-      migration.test = ->(dir){
-        assert migration.connection.table_exists?("horses")
-        assert migration.connection.table_exists?("new_horses")
-        received << dir
-      }
-      migration.migrate :up
-      assert_equal [:both, :up], received
-      assert !migration.connection.table_exists?("horses")
-      assert migration.connection.table_exists?("new_horses")
-      migration.migrate :down
-      assert_equal [:both, :up, :both, :down], received
-      assert migration.connection.table_exists?("horses")
-      assert !migration.connection.table_exists?("new_horses")
-    end
-
-    def test_migrate_revert_whole_migration
-      migration = InvertibleMigration.new
-      [LegacyMigration, InvertibleMigration].each do |klass|
-        revert = RevertWholeMigration.new(klass)
-        migration.migrate :up
-        revert.migrate :up
-        assert !migration.connection.table_exists?("horses")
-        revert.migrate :down
-        assert migration.connection.table_exists?("horses")
-        migration.migrate :down
-        assert !migration.connection.table_exists?("horses")
-      end
-    end
-
-    def test_migrate_nested_revert_whole_migration
-      revert = NestedRevertWholeMigration.new(InvertibleRevertMigration)
-      revert.migrate :down
-      assert revert.connection.table_exists?("horses")
-      revert.migrate :up
-      assert !revert.connection.table_exists?("horses")
-    end
-
-    def test_revert_order
-      block = Proc.new{|t| t.string :name }
-      recorder = ActiveRecord::Migration::CommandRecorder.new(ActiveRecord::Base.connection)
-      recorder.instance_eval do
-        create_table("apples", &block)
-        revert do
-          create_table("bananas", &block)
-          revert do
-            create_table("clementines")
-            create_table("dates")
-          end
-          create_table("elderberries")
-        end
-        revert do
-          create_table("figs")
-          create_table("grapes")
-        end
-      end
-      assert_equal [[:create_table, ["apples"], block], [:drop_table, ["elderberries"], nil],
-                    [:create_table, ["clementines"], nil], [:create_table, ["dates"], nil],
-                    [:drop_table, ["bananas"], block], [:drop_table, ["grapes"], nil],
-                    [:drop_table, ["figs"], nil]], recorder.commands
-    end
-
-    def test_legacy_up
-      LegacyMigration.migrate :up
-      assert ActiveRecord::Base.connection.table_exists?("horses"), "horses should exist"
-    end
-
-    def test_legacy_down
-      LegacyMigration.migrate :up
-      LegacyMigration.migrate :down
-      assert !ActiveRecord::Base.connection.table_exists?("horses"), "horses should not exist"
-    end
-
-    def test_up
-      LegacyMigration.up
-      assert ActiveRecord::Base.connection.table_exists?("horses"), "horses should exist"
-    end
-
-    def test_down
-      LegacyMigration.up
-      LegacyMigration.down
-      assert !ActiveRecord::Base.connection.table_exists?("horses"), "horses should not exist"
-    end
-
-    def test_migrate_down_with_table_name_prefix
-      ActiveRecord::Base.table_name_prefix = 'p_'
-      ActiveRecord::Base.table_name_suffix = '_s'
-      migration = InvertibleMigration.new
-      migration.migrate(:up)
-      assert_nothing_raised { migration.migrate(:down) }
-      assert !ActiveRecord::Base.connection.table_exists?("p_horses_s"), "p_horses_s should not exist"
-    ensure
-      ActiveRecord::Base.table_name_prefix = ActiveRecord::Base.table_name_suffix = ''
-    end
-
-    # MySQL 5.7 and Oracle do not allow to create duplicate indexes on the same columns
-    unless current_adapter?(:MysqlAdapter, :Mysql2Adapter, :OracleAdapter)
-      def test_migrate_revert_add_index_with_name
-        RevertNamedIndexMigration1.new.migrate(:up)
-        RevertNamedIndexMigration2.new.migrate(:up)
-        RevertNamedIndexMigration2.new.migrate(:down)
-
-        connection = ActiveRecord::Base.connection
-        assert connection.index_exists?(:horses, :content),
-               "index on content should exist"
-        assert !connection.index_exists?(:horses, :content, name: "horses_index_named"),
-              "horses_index_named index should not exist"
-      end
-    end
-
-  end
-end
+require "cases/helper"
+
+class Horse < ActiveRecord::Base
+end
+
+module ActiveRecord
+  class InvertibleMigrationTest < ActiveRecord::TestCase
+    class SilentMigration < ActiveRecord::Migration::Current
+      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 InvertibleRevertMigration < SilentMigration
+      def change
+        revert do
+          create_table("horses") do |t|
+            t.column :content, :text
+            t.column :remind_at, :datetime
+          end
+        end
+      end
+    end
+
+    class InvertibleByPartsMigration < SilentMigration
+      attr_writer :test
+      def change
+        create_table("new_horses") do |t|
+          t.column :breed, :string
+        end
+        reversible do |dir|
+          @test.yield :both
+          dir.up    { @test.yield :up }
+          dir.down  { @test.yield :down }
+        end
+        revert do
+          create_table("horses") do |t|
+            t.column :content, :text
+            t.column :remind_at, :datetime
+          end
+        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
+
+    class RemoveIndexMigration1 < SilentMigration
+      def self.up
+        create_table("horses") do |t|
+          t.column :name, :string
+          t.column :color, :string
+          t.index [:name, :color]
+        end
+      end
+    end
+
+    class RemoveIndexMigration2 < SilentMigration
+      def change
+        change_table("horses") do |t|
+          t.remove_index [:name, :color]
+        end
+      end
+    end
+
+    class ChangeColumnDefault1 < SilentMigration
+      def change
+        create_table("horses") do |t|
+          t.column :name, :string, default: "Sekitoba"
+        end
+      end
+    end
+
+    class ChangeColumnDefault2 < SilentMigration
+      def change
+        change_column_default :horses, :name, from: "Sekitoba", to: "Diomed"
+      end
+    end
+
+    class DisableExtension1 < SilentMigration
+      def change
+        enable_extension "hstore"
+      end
+    end
+
+    class DisableExtension2 < SilentMigration
+      def change
+        disable_extension "hstore"
+      end
+    end
+
+    class LegacyMigration < ActiveRecord::Migration::Current
+      def self.up
+        create_table("horses") do |t|
+          t.column :content, :text
+          t.column :remind_at, :datetime
+        end
+      end
+
+      def self.down
+        drop_table("horses")
+      end
+    end
+
+    class RevertWholeMigration < SilentMigration
+      def initialize(name = self.class.name, version = nil, migration)
+        @migration = migration
+        super(name, version)
+      end
+
+      def change
+        revert @migration
+      end
+    end
+
+    class NestedRevertWholeMigration < RevertWholeMigration
+      def change
+        revert { super }
+      end
+    end
+
+    class RevertNamedIndexMigration1 < SilentMigration
+      def change
+        create_table("horses") do |t|
+          t.column :content, :string
+          t.column :remind_at, :datetime
+        end
+        add_index :horses, :content
+      end
+    end
+
+    class RevertNamedIndexMigration2 < SilentMigration
+      def change
+        add_index :horses, :content, name: "horses_index_named"
+      end
+    end
+
+    class RevertCustomForeignKeyTable < SilentMigration
+      def change
+        change_table(:horses) do |t|
+          t.references :owner, foreign_key: { to_table: :developers }
+        end
+      end
+    end
+
+    setup do
+      @verbose_was, ActiveRecord::Migration.verbose = ActiveRecord::Migration.verbose, false
+    end
+
+    teardown do
+      %w[horses new_horses].each do |table|
+        ActiveSupport::Deprecation.silence do
+          if ActiveRecord::Base.connection.table_exists?(table)
+            ActiveRecord::Base.connection.drop_table(table)
+          end
+        end
+      end
+      ActiveRecord::Migration.verbose = @verbose_was
+    end
+
+    def test_no_reverse
+      migration = NonInvertibleMigration.new
+      migration.migrate(:up)
+      assert_raises(IrreversibleMigration) do
+        migration.migrate(:down)
+      end
+    end
+
+    def test_exception_on_removing_index_without_column_option
+      index_definition = ["horses", [:name, :color]]
+      migration1 = RemoveIndexMigration1.new
+      migration1.migrate(:up)
+      assert migration1.connection.index_exists?(*index_definition)
+
+      migration2 = RemoveIndexMigration2.new
+      migration2.migrate(:up)
+      assert_not migration2.connection.index_exists?(*index_definition)
+
+      migration2.migrate(:down)
+      assert migration2.connection.index_exists?(*index_definition)
+    end
+
+    def test_migrate_up
+      migration = InvertibleMigration.new
+      migration.migrate(:up)
+      ActiveSupport::Deprecation.silence { assert migration.connection.table_exists?("horses"), "horses should exist" }
+    end
+
+    def test_migrate_down
+      migration = InvertibleMigration.new
+      migration.migrate :up
+      migration.migrate :down
+      ActiveSupport::Deprecation.silence { assert !migration.connection.table_exists?("horses") }
+    end
+
+    def test_migrate_revert
+      migration = InvertibleMigration.new
+      revert = InvertibleRevertMigration.new
+      migration.migrate :up
+      revert.migrate :up
+      ActiveSupport::Deprecation.silence { assert !migration.connection.table_exists?("horses") }
+      revert.migrate :down
+      ActiveSupport::Deprecation.silence { assert migration.connection.table_exists?("horses") }
+      migration.migrate :down
+      ActiveSupport::Deprecation.silence { assert !migration.connection.table_exists?("horses") }
+    end
+
+    def test_migrate_revert_by_part
+      InvertibleMigration.new.migrate :up
+      received = []
+      migration = InvertibleByPartsMigration.new
+      migration.test = ->(dir){
+        ActiveSupport::Deprecation.silence do
+          assert migration.connection.table_exists?("horses")
+          assert migration.connection.table_exists?("new_horses")
+        end
+        received << dir
+      }
+      migration.migrate :up
+      assert_equal [:both, :up], received
+      ActiveSupport::Deprecation.silence do
+        assert !migration.connection.table_exists?("horses")
+        assert migration.connection.table_exists?("new_horses")
+      end
+      migration.migrate :down
+      assert_equal [:both, :up, :both, :down], received
+      ActiveSupport::Deprecation.silence do
+        assert migration.connection.table_exists?("horses")
+        assert !migration.connection.table_exists?("new_horses")
+      end
+    end
+
+    def test_migrate_revert_whole_migration
+      migration = InvertibleMigration.new
+      [LegacyMigration, InvertibleMigration].each do |klass|
+        revert = RevertWholeMigration.new(klass)
+        migration.migrate :up
+        revert.migrate :up
+        ActiveSupport::Deprecation.silence { assert !migration.connection.table_exists?("horses") }
+        revert.migrate :down
+        ActiveSupport::Deprecation.silence { assert migration.connection.table_exists?("horses") }
+        migration.migrate :down
+        ActiveSupport::Deprecation.silence { assert !migration.connection.table_exists?("horses") }
+      end
+    end
+
+    def test_migrate_nested_revert_whole_migration
+      revert = NestedRevertWholeMigration.new(InvertibleRevertMigration)
+      revert.migrate :down
+      ActiveSupport::Deprecation.silence { assert revert.connection.table_exists?("horses") }
+      revert.migrate :up
+      ActiveSupport::Deprecation.silence { assert !revert.connection.table_exists?("horses") }
+    end
+
+    def test_migrate_revert_change_column_default
+      migration1 = ChangeColumnDefault1.new
+      migration1.migrate(:up)
+      assert_equal "Sekitoba", Horse.new.name
+
+      migration2 = ChangeColumnDefault2.new
+      migration2.migrate(:up)
+      Horse.reset_column_information
+      assert_equal "Diomed", Horse.new.name
+
+      migration2.migrate(:down)
+      Horse.reset_column_information
+      assert_equal "Sekitoba", Horse.new.name
+    end
+
+    if current_adapter?(:PostgreSQLAdapter)
+      def test_migrate_enable_and_disable_extension
+        migration1 = InvertibleMigration.new
+        migration2 = DisableExtension1.new
+        migration3 = DisableExtension2.new
+
+        migration1.migrate(:up)
+        migration2.migrate(:up)
+        assert_equal true, Horse.connection.extension_enabled?('hstore')
+
+        migration3.migrate(:up)
+        assert_equal false, Horse.connection.extension_enabled?('hstore')
+
+        migration3.migrate(:down)
+        assert_equal true, Horse.connection.extension_enabled?('hstore')
+
+        migration2.migrate(:down)
+        assert_equal false, Horse.connection.extension_enabled?('hstore')
+      end
+    end
+
+    def test_revert_order
+      block = Proc.new{|t| t.string :name }
+      recorder = ActiveRecord::Migration::CommandRecorder.new(ActiveRecord::Base.connection)
+      recorder.instance_eval do
+        create_table("apples", &block)
+        revert do
+          create_table("bananas", &block)
+          revert do
+            create_table("clementines")
+            create_table("dates")
+          end
+          create_table("elderberries")
+        end
+        revert do
+          create_table("figs")
+          create_table("grapes")
+        end
+      end
+      assert_equal [[:create_table, ["apples"], block], [:drop_table, ["elderberries"], nil],
+                    [:create_table, ["clementines"], nil], [:create_table, ["dates"], nil],
+                    [:drop_table, ["bananas"], block], [:drop_table, ["grapes"], nil],
+                    [:drop_table, ["figs"], nil]], recorder.commands
+    end
+
+    def test_legacy_up
+      LegacyMigration.migrate :up
+      ActiveSupport::Deprecation.silence { assert ActiveRecord::Base.connection.table_exists?("horses"), "horses should exist" }
+    end
+
+    def test_legacy_down
+      LegacyMigration.migrate :up
+      LegacyMigration.migrate :down
+      ActiveSupport::Deprecation.silence { assert !ActiveRecord::Base.connection.table_exists?("horses"), "horses should not exist" }
+    end
+
+    def test_up
+      LegacyMigration.up
+      ActiveSupport::Deprecation.silence { assert ActiveRecord::Base.connection.table_exists?("horses"), "horses should exist" }
+    end
+
+    def test_down
+      LegacyMigration.up
+      LegacyMigration.down
+      ActiveSupport::Deprecation.silence { assert !ActiveRecord::Base.connection.table_exists?("horses"), "horses should not exist" }
+    end
+
+    def test_migrate_down_with_table_name_prefix
+      ActiveRecord::Base.table_name_prefix = 'p_'
+      ActiveRecord::Base.table_name_suffix = '_s'
+      migration = InvertibleMigration.new
+      migration.migrate(:up)
+      assert_nothing_raised { migration.migrate(:down) }
+      ActiveSupport::Deprecation.silence { assert !ActiveRecord::Base.connection.table_exists?("p_horses_s"), "p_horses_s should not exist" }
+    ensure
+      ActiveRecord::Base.table_name_prefix = ActiveRecord::Base.table_name_suffix = ''
+    end
+
+    def test_migrations_can_handle_foreign_keys_to_specific_tables
+      migration = RevertCustomForeignKeyTable.new
+      InvertibleMigration.migrate(:up)
+      migration.migrate(:up)
+      migration.migrate(:down)
+    end
+
+    # MySQL 5.7 and Oracle do not allow to create duplicate indexes on the same columns
+    unless current_adapter?(:Mysql2Adapter, :OracleAdapter)
+      def test_migrate_revert_add_index_with_name
+        RevertNamedIndexMigration1.new.migrate(:up)
+        RevertNamedIndexMigration2.new.migrate(:up)
+        RevertNamedIndexMigration2.new.migrate(:down)
+
+        connection = ActiveRecord::Base.connection
+        assert connection.index_exists?(:horses, :content),
+               "index on content should exist"
+        assert !connection.index_exists?(:horses, :content, name: "horses_index_named"),
+              "horses_index_named index should not exist"
+      end
+    end
+
+  end
+end