ibm_db 3.0.3 → 5.0.3

data/test/cases/migration/references_index_test.rb

@@ -23,12 +23,12 @@ module ActiveRecord
         assert connection.index_exists?(table_name, :foo_id, :name => :index_testings_on_foo_id)
       end
 
-      def test_does_not_create_index
+      def test_creates_index_by_default_even_if_index_option_is_not_passed
         connection.create_table table_name do |t|
           t.references :foo
         end
 
-        assert_not connection.index_exists?(table_name, :foo_id, :name => :index_testings_on_foo_id)
+        assert connection.index_exists?(table_name, :foo_id, :name => :index_testings_on_foo_id)
       end
 
       def test_does_not_create_index_explicit
@@ -68,13 +68,13 @@ module ActiveRecord
         assert connection.index_exists?(table_name, :foo_id, :name => :index_testings_on_foo_id)
       end
 
-      def test_does_not_create_index_for_existing_table
+      def test_creates_index_for_existing_table_even_if_index_option_is_not_passed
         connection.create_table table_name
         connection.change_table table_name do |t|
           t.references :foo
         end
 
-        assert_not connection.index_exists?(table_name, :foo_id, :name => :index_testings_on_foo_id)
+        assert connection.index_exists?(table_name, :foo_id, :name => :index_testings_on_foo_id)
       end
 
       def test_does_not_create_index_for_existing_table_explicit

data/test/cases/migration/references_statements_test.rb

@@ -5,7 +5,7 @@ module ActiveRecord
     class ReferencesStatementsTest < ActiveRecord::TestCase
       include ActiveRecord::Migration::TestHelper
 
-      self.use_transactional_fixtures = false
+      self.use_transactional_tests = false
 
       def setup
         super
@@ -30,14 +30,14 @@ module ActiveRecord
         assert column_exists?(table_name, :taggable_type, :string)
       end
 
-      def test_creates_reference_id_index
-        add_reference table_name, :user, index: true
-        assert index_exists?(table_name, :user_id)
+      def test_does_not_create_reference_id_index_if_index_is_false
+        add_reference table_name, :user, index: false
+        assert_not index_exists?(table_name, :user_id)
       end
 
-      def test_does_not_create_reference_id_index
+      def test_create_reference_id_index_even_if_index_option_is_passed
         add_reference table_name, :user
-        assert_not index_exists?(table_name, :user_id)
+        assert index_exists?(table_name, :user_id)
       end
 
       def test_creates_polymorphic_index
@@ -50,11 +50,31 @@ module ActiveRecord
         assert column_exists?(table_name, :taggable_type, :string, default: 'Photo')
       end
 
+      def test_creates_reference_type_column_with_not_null
+        connection.create_table table_name, force: true do |t|
+          t.references :taggable, null: false, polymorphic: true
+        end
+        assert column_exists?(table_name, :taggable_id, :integer, null: false)
+        assert column_exists?(table_name, :taggable_type, :string, null: false)
+      end
+
+      def test_does_not_share_options_with_reference_type_column
+        add_reference table_name, :taggable, type: :integer, limit: 2, polymorphic: true
+        assert column_exists?(table_name, :taggable_id, :integer, limit: 2)
+        assert column_exists?(table_name, :taggable_type, :string)
+        assert_not column_exists?(table_name, :taggable_type, :string, limit: 2)
+      end
+
       def test_creates_named_index
         add_reference table_name, :tag, index: { name: 'index_taggings_on_tag_id' }
         assert index_exists?(table_name, :tag_id, name: 'index_taggings_on_tag_id')
       end
 
+      def test_creates_named_unique_index
+        add_reference table_name, :tag, index: { name: 'index_taggings_on_tag_id', unique: true }
+        assert index_exists?(table_name, :tag_id, name: 'index_taggings_on_tag_id', unique: true )
+      end
+
       def test_creates_reference_id_with_specified_type
         add_reference table_name, :user, type: :string
         assert column_exists?(table_name, :user_id, :string)

data/test/cases/migration/rename_table_test.rb

@@ -5,7 +5,7 @@ module ActiveRecord
     class RenameTableTest < ActiveRecord::TestCase
       include ActiveRecord::Migration::TestHelper
 
-      self.use_transactional_fixtures = false
+      self.use_transactional_tests = false
 
       def setup
         super
@@ -15,7 +15,7 @@ module ActiveRecord
       end
 
       def teardown
-        rename_table :octopi, :test_models if connection.table_exists? :octopi
+        ActiveSupport::Deprecation.silence { rename_table :octopi, :test_models if connection.table_exists? :octopi }
         super
       end
 
@@ -39,33 +39,35 @@ module ActiveRecord
         end
       end
 
-      def test_rename_table
-        rename_table :test_models, :octopi
+      unless current_adapter?(:FbAdapter) # Firebird cannot rename tables
+        def test_rename_table
+          rename_table :test_models, :octopi
 
-        connection.execute "INSERT INTO octopi (#{connection.quote_column_name('id')}, #{connection.quote_column_name('url')}) VALUES (1, 'http://www.foreverflying.com/octopus-black7.jpg')"
+          connection.execute "INSERT INTO octopi (#{connection.quote_column_name('id')}, #{connection.quote_column_name('url')}) VALUES (1, 'http://www.foreverflying.com/octopus-black7.jpg')"
 
-        assert_equal 'http://www.foreverflying.com/octopus-black7.jpg', connection.select_value("SELECT url FROM octopi WHERE id=1")
-      end
+          assert_equal 'http://www.foreverflying.com/octopus-black7.jpg', connection.select_value("SELECT url FROM octopi WHERE id=1")
+        end
 
-      def test_rename_table_with_an_index
-        add_index :test_models, :url
+        def test_rename_table_with_an_index
+          add_index :test_models, :url
 
-        rename_table :test_models, :octopi
+          rename_table :test_models, :octopi
 
-        connection.execute "INSERT INTO octopi (#{connection.quote_column_name('id')}, #{connection.quote_column_name('url')}) VALUES (1, 'http://www.foreverflying.com/octopus-black7.jpg')"
+          connection.execute "INSERT INTO octopi (#{connection.quote_column_name('id')}, #{connection.quote_column_name('url')}) VALUES (1, 'http://www.foreverflying.com/octopus-black7.jpg')"
 
-        assert_equal 'http://www.foreverflying.com/octopus-black7.jpg', connection.select_value("SELECT url FROM octopi WHERE id=1")
-        index = connection.indexes(:octopi).first
-        assert index.columns.include?("url")
-        assert_equal 'index_octopi_on_url', index.name
-      end
+          assert_equal 'http://www.foreverflying.com/octopus-black7.jpg', connection.select_value("SELECT url FROM octopi WHERE id=1")
+          index = connection.indexes(:octopi).first
+          assert index.columns.include?("url")
+          assert_equal 'index_octopi_on_url', index.name
+        end
 
-      def test_rename_table_does_not_rename_custom_named_index
-        add_index :test_models, :url, name: 'special_url_idx'
+        def test_rename_table_does_not_rename_custom_named_index
+          add_index :test_models, :url, name: 'special_url_idx'
 
-        rename_table :test_models, :octopi
+          rename_table :test_models, :octopi
 
-        assert_equal ['special_url_idx'], connection.indexes(:octopi).map(&:name)
+          assert_equal ['special_url_idx'], connection.indexes(:octopi).map(&:name)
+        end
       end
 
       if current_adapter?(:PostgreSQLAdapter)
@@ -78,14 +80,12 @@ module ActiveRecord
         end
 
         def test_renaming_table_doesnt_attempt_to_rename_non_existent_sequences
-          enable_extension!('uuid-ossp', connection)
           connection.create_table :cats, id: :uuid
           assert_nothing_raised { rename_table :cats, :felines }
-          assert connection.table_exists? :felines
+          ActiveSupport::Deprecation.silence { assert connection.table_exists? :felines }
         ensure
-          disable_extension!('uuid-ossp', connection)
-          connection.drop_table :cats if connection.table_exists? :cats
-          connection.drop_table :felines if connection.table_exists? :felines
+          connection.drop_table :cats, if_exists: true
+          connection.drop_table :felines, if_exists: true
         end
       end
     end

data/test/cases/migration_test.rb

@@ -1,6 +1,7 @@
-require "cases/helper"
-require "cases/migration/helper"
+require 'cases/helper'
+require 'cases/migration/helper'
 require 'bigdecimal/util'
+require 'concurrent/atomic/count_down_latch'
 
 require 'models/person'
 require 'models/topic'
@@ -14,9 +15,9 @@ require MIGRATIONS_ROOT + "/decimal/1_give_me_big_numbers"
 
 class BigNumber < ActiveRecord::Base
   unless current_adapter?(:PostgreSQLAdapter, :SQLite3Adapter)
-    attribute :value_of_e, Type::Integer.new
+    attribute :value_of_e, :integer
   end
-  attribute :my_house_population, Type::Integer.new
+  attribute :my_house_population, :integer
 end
 
 class Reminder < ActiveRecord::Base; end
@@ -24,18 +25,10 @@ class Reminder < ActiveRecord::Base; end
 class Thing < ActiveRecord::Base; end
 
 class MigrationTest < ActiveRecord::TestCase
-  self.use_transactional_fixtures = false
+  self.use_transactional_tests = false
 
   fixtures :people
 
-  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
-    @ibm_db_rename_supported =  server_type.include?('::IBM_DB2_LUW_COBRA') ||
-                        server_type.class.name.include?('::IBM_IDS') ||
-      (server_type.include?('IBM_DB2_ZOS') && !server_type.include?('IBM_DB2_ZOS_8'))
-  end
-  
   def setup
     super
     %w(reminders people_reminders prefix_reminders_suffix p_things_s).each do |table|
@@ -76,6 +69,10 @@ class MigrationTest < ActiveRecord::TestCase
     ActiveRecord::Migration.verbose = @verbose_was
   end
 
+  def test_migration_version_matches_component_version
+    assert_equal ActiveRecord::VERSION::STRING.to_f, ActiveRecord::Migration.current_version
+  end
+
   def test_migrator_versions
     migrations_path = MIGRATIONS_ROOT + "/valid"
     old_path = ActiveRecord::Migrator.migrations_paths
@@ -83,22 +80,21 @@ class MigrationTest < ActiveRecord::TestCase
 
     ActiveRecord::Migrator.up(migrations_path)
     assert_equal 3, ActiveRecord::Migrator.current_version
-    assert_equal 3, ActiveRecord::Migrator.last_version
     assert_equal false, ActiveRecord::Migrator.needs_migration?
 
     ActiveRecord::Migrator.down(MIGRATIONS_ROOT + "/valid")
     assert_equal 0, ActiveRecord::Migrator.current_version
-    assert_equal 3, ActiveRecord::Migrator.last_version
     assert_equal true, ActiveRecord::Migrator.needs_migration?
 
-    ActiveRecord::SchemaMigration.create!(:version => ActiveRecord::Migrator.last_version)
+    ActiveRecord::SchemaMigration.create!(version: 3)
     assert_equal true, ActiveRecord::Migrator.needs_migration?
   ensure
     ActiveRecord::Migrator.migrations_paths = old_path
   end
 
   def test_migration_detection_without_schema_migration_table
-    ActiveRecord::Base.connection.drop_table('schema_migrations') if ActiveRecord::Base.connection.table_exists?('schema_migrations')
+    ActiveRecord::Base.connection.drop_table 'schema_migrations'
+	#, if_exists: true
 
     migrations_path = MIGRATIONS_ROOT + "/valid"
     old_path = ActiveRecord::Migrator.migrations_paths
@@ -123,14 +119,10 @@ class MigrationTest < ActiveRecord::TestCase
   end
 
   def test_migration_version
-    ActiveRecord::Migrator.run(:up, MIGRATIONS_ROOT + "/version_check", 20131219224947)
+    assert_nothing_raised { ActiveRecord::Migrator.run(:up, MIGRATIONS_ROOT + "/version_check", 20131219224947) }
   end
 
   def test_create_table_with_force_true_does_not_drop_nonexisting_table
-    if Person.connection.table_exists?(:testings2)
-      Person.connection.drop_table :testings2
-    end
-
     # using a copy as we need the drop_table method to
     # continue to work for the ensure block of the test
     temp_conn = Person.connection.dup
@@ -141,20 +133,17 @@ class MigrationTest < ActiveRecord::TestCase
       t.column :foo, :string
     end
   ensure
-    Person.connection.drop_table :testings2 rescue nil
-  end
-
-  def connection
-    ActiveRecord::Base.connection
+    Person.connection.drop_table :testings2
+	#, if_exists: true
   end
 
   def test_migration_instance_has_connection
-    migration = Class.new(ActiveRecord::Migration).new
-    assert_equal connection, migration.connection
+    migration = Class.new(ActiveRecord::Migration::Current).new
+    assert_equal ActiveRecord::Base.connection, migration.connection
   end
 
   def test_method_missing_delegates_to_connection
-    migration = Class.new(ActiveRecord::Migration) {
+    migration = Class.new(ActiveRecord::Migration::Current) {
       def connection
         Class.new {
           def create_table; "hi mom!"; end
@@ -170,6 +159,7 @@ class MigrationTest < ActiveRecord::TestCase
 
     assert !BigNumber.table_exists?
     GiveMeBigNumbers.up
+    BigNumber.reset_column_information
 
     assert BigNumber.create(
       :bank_balance => 1586.43,
@@ -190,17 +180,9 @@ class MigrationTest < ActiveRecord::TestCase
 
     # TODO: set world_population >= 2**62 to cover 64-bit platforms and test
     # is_a?(Bignum)
-    unless current_adapter?(:IBM_DBAdapter)
-        assert_kind_of Integer, b.world_population
-    else
-        assert_kind_of BigDecimal, b.world_population
-    end
+    assert_kind_of Integer, b.world_population
     assert_equal 6000000000, b.world_population
-    unless current_adapter?(:IBM_DBAdapter)
-        assert_kind_of Fixnum, b.my_house_population
-    else
-        assert_kind_of BigDecimal, b.my_house_population
-    end
+    assert_kind_of Integer, b.my_house_population
     assert_equal 3, b.my_house_population
     assert_kind_of BigDecimal, b.bank_balance
     assert_equal BigDecimal("1586.43"), b.bank_balance
@@ -216,8 +198,6 @@ class MigrationTest < ActiveRecord::TestCase
       # of 0, they take on the compile-time limit for precision and scale,
       # so the following should succeed unless you have used really wacky
       # compilation options
-      # - SQLite2 has the default behavior of preserving all data sent in,
-      # 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?(:SQLite3Adapter)
@@ -226,11 +206,7 @@ class MigrationTest < ActiveRecord::TestCase
       assert_in_delta BigDecimal("2.71828182845905"), b.value_of_e, 0.00000000000001
     else
       # - SQL standard is an integer
-      unless current_adapter?(:IBM_DBAdapter)
-          assert_kind_of Fixnum, b.value_of_e
-      else
-          assert_kind_of BigDecimal, b.value_of_e
-      end
+      assert_kind_of Integer, b.value_of_e
       assert_equal 2, b.value_of_e
     end
 
@@ -254,7 +230,7 @@ class MigrationTest < ActiveRecord::TestCase
     assert_raise(ActiveRecord::StatementInvalid) { Reminder.first }
   end
 
-  class MockMigration < ActiveRecord::Migration
+  class MockMigration < ActiveRecord::Migration::Current
     attr_reader :went_up, :went_down
     def initialize
       @went_up   = false
@@ -296,7 +272,7 @@ class MigrationTest < ActiveRecord::TestCase
     def test_migrator_one_up_with_exception_and_rollback
       assert_no_column Person, :last_name
 
-      migration = Class.new(ActiveRecord::Migration) {
+      migration = Class.new(ActiveRecord::Migration::Current) {
         def version; 100 end
         def migrate(x)
           add_column "people", "last_name", :string
@@ -317,7 +293,7 @@ class MigrationTest < ActiveRecord::TestCase
     def test_migrator_one_up_with_exception_and_rollback_using_run
       assert_no_column Person, :last_name
 
-      migration = Class.new(ActiveRecord::Migration) {
+      migration = Class.new(ActiveRecord::Migration::Current) {
         def version; 100 end
         def migrate(x)
           add_column "people", "last_name", :string
@@ -329,7 +305,7 @@ class MigrationTest < ActiveRecord::TestCase
 
       e = assert_raise(StandardError) { migrator.run }
 
-      assert_equal "An error has occurred, this migration was canceled:\n\nSomething broke", e.message
+      assert_equal "An error has occurred, this and all later migrations canceled:\n\nSomething broke", e.message
 
       assert_no_column Person, :last_name,
         "On error, the Migrator should revert schema changes but it did not."
@@ -338,7 +314,7 @@ class MigrationTest < ActiveRecord::TestCase
     def test_migration_without_transaction
       assert_no_column Person, :last_name
 
-      migration = Class.new(ActiveRecord::Migration) {
+      migration = Class.new(ActiveRecord::Migration::Current) {
         self.disable_ddl_transaction!
 
         def version; 101 end
@@ -382,6 +358,110 @@ class MigrationTest < ActiveRecord::TestCase
     Reminder.reset_table_name
   end
 
+  def test_internal_metadata_table_name
+    original_internal_metadata_table_name = ActiveRecord::Base.internal_metadata_table_name
+
+    assert_equal "ar_internal_metadata", ActiveRecord::InternalMetadata.table_name
+    ActiveRecord::Base.table_name_prefix = "p_"
+    ActiveRecord::Base.table_name_suffix = "_s"
+    Reminder.reset_table_name
+    assert_equal "p_ar_internal_metadata_s", ActiveRecord::InternalMetadata.table_name
+    ActiveRecord::Base.internal_metadata_table_name = "changed"
+    Reminder.reset_table_name
+    assert_equal "p_changed_s", ActiveRecord::InternalMetadata.table_name
+    ActiveRecord::Base.table_name_prefix = ""
+    ActiveRecord::Base.table_name_suffix = ""
+    Reminder.reset_table_name
+    assert_equal "changed", ActiveRecord::InternalMetadata.table_name
+  ensure
+    ActiveRecord::Base.internal_metadata_table_name = original_internal_metadata_table_name
+    Reminder.reset_table_name
+  end
+
+  def test_internal_metadata_stores_environment
+    current_env     = ActiveRecord::ConnectionHandling::DEFAULT_ENV.call
+    migrations_path = MIGRATIONS_ROOT + "/valid"
+    old_path        = ActiveRecord::Migrator.migrations_paths
+    ActiveRecord::Migrator.migrations_paths = migrations_path
+
+    ActiveRecord::Migrator.up(migrations_path)
+    assert_equal current_env, ActiveRecord::InternalMetadata[:environment]
+
+    original_rails_env  = ENV["RAILS_ENV"]
+    original_rack_env   = ENV["RACK_ENV"]
+    ENV["RAILS_ENV"]    = ENV["RACK_ENV"] = "foofoo"
+    new_env     = ActiveRecord::ConnectionHandling::DEFAULT_ENV.call
+
+    refute_equal current_env, new_env
+
+    sleep 1 # mysql by default does not store fractional seconds in the database
+    ActiveRecord::Migrator.up(migrations_path)
+    assert_equal new_env, ActiveRecord::InternalMetadata[:environment]
+  ensure
+    ActiveRecord::Migrator.migrations_paths = old_path
+    ENV["RAILS_ENV"] = original_rails_env
+    ENV["RACK_ENV"]  = original_rack_env
+  end
+
+
+  def test_migration_sets_internal_metadata_even_when_fully_migrated
+    current_env     = ActiveRecord::ConnectionHandling::DEFAULT_ENV.call
+    migrations_path = MIGRATIONS_ROOT + "/valid"
+    old_path        = ActiveRecord::Migrator.migrations_paths
+    ActiveRecord::Migrator.migrations_paths = migrations_path
+
+    ActiveRecord::Migrator.up(migrations_path)
+    assert_equal current_env, ActiveRecord::InternalMetadata[:environment]
+
+    original_rails_env  = ENV["RAILS_ENV"]
+    original_rack_env   = ENV["RACK_ENV"]
+    ENV["RAILS_ENV"]    = ENV["RACK_ENV"] = "foofoo"
+    new_env     = ActiveRecord::ConnectionHandling::DEFAULT_ENV.call
+
+    refute_equal current_env, new_env
+
+    sleep 1 # mysql by default does not store fractional seconds in the database
+
+    ActiveRecord::Migrator.up(migrations_path)
+    assert_equal new_env, ActiveRecord::InternalMetadata[:environment]
+  ensure
+    ActiveRecord::Migrator.migrations_paths = old_path
+    ENV["RAILS_ENV"] = original_rails_env
+    ENV["RACK_ENV"]  = original_rack_env
+  end
+
+  def test_internal_metadata_stores_environment_when_other_data_exists
+    ActiveRecord::InternalMetadata.delete_all
+    ActiveRecord::InternalMetadata[:foo]  = 'bar'
+
+    current_env     = ActiveRecord::ConnectionHandling::DEFAULT_ENV.call
+    migrations_path = MIGRATIONS_ROOT + "/valid"
+    old_path        = ActiveRecord::Migrator.migrations_paths
+    ActiveRecord::Migrator.migrations_paths = migrations_path
+
+    current_env     = ActiveRecord::ConnectionHandling::DEFAULT_ENV.call
+    ActiveRecord::Migrator.up(migrations_path)
+    assert_equal current_env, ActiveRecord::InternalMetadata[:environment]
+    assert_equal 'bar', ActiveRecord::InternalMetadata[:foo]
+  ensure
+    ActiveRecord::Migrator.migrations_paths = old_path
+  end
+
+  def test_rename_internal_metadata_table
+    original_internal_metadata_table_name = ActiveRecord::Base.internal_metadata_table_name
+
+    ActiveRecord::Base.internal_metadata_table_name = "active_record_internal_metadatas"
+    Reminder.reset_table_name
+
+    ActiveRecord::Base.internal_metadata_table_name = original_internal_metadata_table_name
+    Reminder.reset_table_name
+
+    assert_equal "ar_internal_metadata", ActiveRecord::InternalMetadata.table_name
+  ensure
+    ActiveRecord::Base.internal_metadata_table_name = original_internal_metadata_table_name
+    Reminder.reset_table_name
+  end
+
   def test_proper_table_name_on_migration
     reminder_class = new_isolated_reminder_class
     migration = ActiveRecord::Migration.new
@@ -417,6 +497,7 @@ class MigrationTest < ActiveRecord::TestCase
     Thing.reset_table_name
     Thing.reset_sequence_name
     WeNeedThings.up
+    Thing.reset_column_information
 
     assert Thing.create("content" => "hello world")
     assert_equal "hello world", Thing.first.content
@@ -436,6 +517,7 @@ class MigrationTest < ActiveRecord::TestCase
     ActiveRecord::Base.table_name_suffix = '_suffix'
     Reminder.reset_table_name
     Reminder.reset_sequence_name
+    Reminder.reset_column_information
     WeNeedReminders.up
     assert Reminder.create("content" => "hello world", "remind_at" => Time.now)
     assert_equal "hello world", Reminder.first.content
@@ -447,8 +529,6 @@ class MigrationTest < ActiveRecord::TestCase
   end
 
   def test_create_table_with_binary_column
-    Person.connection.drop_table :binary_testings rescue nil
-
     assert_nothing_raised {
       Person.connection.create_table :binary_testings do |t|
         t.column "data", :binary, :null => false
@@ -459,13 +539,13 @@ class MigrationTest < ActiveRecord::TestCase
     data_column = columns.detect { |c| c.name == "data" }
 
     assert_nil data_column.default
-
-    Person.connection.drop_table :binary_testings rescue nil
+  ensure
+    Person.connection.drop_table :binary_testings
+	#, if_exists: true
   end
 
   unless mysql_enforcing_gtid_consistency?
     def test_create_table_with_query
-      Person.connection.drop_table :table_from_query_testings rescue nil
       Person.connection.create_table(:person, force: true)
 
       Person.connection.create_table :table_from_query_testings, as: "SELECT id FROM person"
@@ -473,12 +553,11 @@ class MigrationTest < ActiveRecord::TestCase
       columns = Person.connection.columns(:table_from_query_testings)
       assert_equal 1, columns.length
       assert_equal "id", columns.first.name
-
+    ensure
       Person.connection.drop_table :table_from_query_testings rescue nil
     end
 
     def test_create_table_with_query_from_relation
-      Person.connection.drop_table :table_from_query_testings rescue nil
       Person.connection.create_table(:person, force: true)
 
       Person.connection.create_table :table_from_query_testings, as: Person.select(:id)
@@ -486,11 +565,29 @@ class MigrationTest < ActiveRecord::TestCase
       columns = Person.connection.columns(:table_from_query_testings)
       assert_equal 1, columns.length
       assert_equal "id", columns.first.name
-
+    ensure
       Person.connection.drop_table :table_from_query_testings rescue nil
     end
   end
 
+  if current_adapter?(:SQLite3Adapter)
+    def test_allows_sqlite3_rollback_on_invalid_column_type
+      Person.connection.create_table :something, force: true do |t|
+        t.column :number, :integer
+        t.column :name, :string
+        t.column :foo, :bar
+      end
+      assert Person.connection.column_exists?(:something, :foo)
+      assert_nothing_raised { Person.connection.remove_column :something, :foo, :bar }
+      assert !Person.connection.column_exists?(:something, :foo)
+      assert Person.connection.column_exists?(:something, :name)
+      assert Person.connection.column_exists?(:something, :number)
+    ensure
+      Person.connection.drop_table :something
+	  #, if_exists: true
+    end
+  end
+
   if current_adapter? :OracleAdapter
     def test_create_table_with_custom_sequence_name
       # table name is 29 chars, the standard sequence name will
@@ -528,24 +625,105 @@ class MigrationTest < ActiveRecord::TestCase
     end
   end
 
-  if current_adapter?(:MysqlAdapter, :Mysql2Adapter, :PostgreSQLAdapter)
-    def test_out_of_range_limit_should_raise
-      Person.connection.drop_table :test_limits rescue nil
-      assert_raise(ActiveRecord::ActiveRecordError, "integer limit didn't raise") do
+  if current_adapter?(:Mysql2Adapter, :PostgreSQLAdapter)
+    def test_out_of_range_integer_limit_should_raise
+      e = assert_raise(ActiveRecord::ActiveRecordError, "integer limit didn't raise") do
         Person.connection.create_table :test_integer_limits, :force => true do |t|
           t.column :bigone, :integer, :limit => 10
         end
       end
 
-      unless current_adapter?(:PostgreSQLAdapter)
-        assert_raise(ActiveRecord::ActiveRecordError, "text limit didn't raise") do
-          Person.connection.create_table :test_text_limits, :force => true do |t|
-            t.column :bigtext, :text, :limit => 0xfffffffff
-          end
+      assert_match(/No integer type has byte size 10/, e.message)
+    ensure
+      Person.connection.drop_table :test_integer_limits
+	  #, if_exists: true
+    end
+  end
+
+  if current_adapter?(:Mysql2Adapter)
+    def test_out_of_range_text_limit_should_raise
+      e = assert_raise(ActiveRecord::ActiveRecordError, "text limit didn't raise") do
+        Person.connection.create_table :test_text_limits, force: true do |t|
+          t.text :bigtext, limit: 0xfffffffff
         end
       end
 
-      Person.connection.drop_table :test_limits rescue nil
+      assert_match(/No text type has byte length #{0xfffffffff}/, e.message)
+    ensure
+      Person.connection.drop_table :test_text_limits
+	  #, if_exists: true
+    end
+  end
+
+  if ActiveRecord::Base.connection.supports_advisory_locks?
+    def test_migrator_generates_valid_lock_id
+      migration = Class.new(ActiveRecord::Migration::Current).new
+      migrator = ActiveRecord::Migrator.new(:up, [migration], 100)
+
+      lock_id = migrator.send(:generate_migrator_advisory_lock_id)
+
+      assert ActiveRecord::Base.connection.get_advisory_lock(lock_id),
+        "the Migrator should have generated a valid lock id, but it didn't"
+      assert ActiveRecord::Base.connection.release_advisory_lock(lock_id),
+        "the Migrator should have generated a valid lock id, but it didn't"
+    end
+
+    def test_generate_migrator_advisory_lock_id
+      # It is important we are consistent with how we generate this so that
+      # exclusive locking works across migrator versions
+      migration = Class.new(ActiveRecord::Migration::Current).new
+      migrator = ActiveRecord::Migrator.new(:up, [migration], 100)
+
+      lock_id = migrator.send(:generate_migrator_advisory_lock_id)
+
+      current_database = ActiveRecord::Base.connection.current_database
+      salt = ActiveRecord::Migrator::MIGRATOR_SALT
+      expected_id = Zlib.crc32(current_database) * salt
+
+      assert lock_id == expected_id, "expected lock id generated by the migrator to be #{expected_id}, but it was #{lock_id} instead"
+      assert lock_id.bit_length <= 63, "lock id must be a signed integer of max 63 bits magnitude"
+    end
+
+    def test_migrator_one_up_with_unavailable_lock
+      assert_no_column Person, :last_name
+
+      migration = Class.new(ActiveRecord::Migration::Current) {
+        def version; 100 end
+        def migrate(x)
+          add_column "people", "last_name", :string
+        end
+      }.new
+
+      migrator = ActiveRecord::Migrator.new(:up, [migration], 100)
+      lock_id = migrator.send(:generate_migrator_advisory_lock_id)
+
+      with_another_process_holding_lock(lock_id) do
+        assert_raise(ActiveRecord::ConcurrentMigrationError) { migrator.migrate }
+      end
+
+      assert_no_column Person, :last_name,
+        "without an advisory lock, the Migrator should not make any changes, but it did."
+    end
+
+    def test_migrator_one_up_with_unavailable_lock_using_run
+      assert_no_column Person, :last_name
+
+      migration = Class.new(ActiveRecord::Migration::Current) {
+        def version; 100 end
+        def migrate(x)
+          add_column "people", "last_name", :string
+        end
+      }.new
+
+      migrator = ActiveRecord::Migrator.new(:up, [migration], 100)
+      lock_id = migrator.send(:generate_migrator_advisory_lock_id)
+
+      with_another_process_holding_lock(lock_id) do
+        assert_raise(ActiveRecord::ConcurrentMigrationError) { migrator.run }
+      end
+
+      assert_no_column Person, :last_name,
+        "without an advisory lock, the Migrator should not make any changes, but it did."
     end
   end
 
@@ -558,6 +736,30 @@ class MigrationTest < ActiveRecord::TestCase
         def self.base_class; self; end
       }
     end
+
+    def with_another_process_holding_lock(lock_id)
+      thread_lock = Concurrent::CountDownLatch.new
+      test_terminated = Concurrent::CountDownLatch.new
+
+      other_process = Thread.new do
+        begin
+          conn = ActiveRecord::Base.connection_pool.checkout
+          conn.get_advisory_lock(lock_id)
+          thread_lock.count_down
+          test_terminated.wait # hold the lock open until we tested everything
+        ensure
+          conn.release_advisory_lock(lock_id)
+          ActiveRecord::Base.connection_pool.checkin(conn)
+        end
+      end
+
+      thread_lock.wait # wait until the 'other process' has the lock
+
+      yield
+
+      test_terminated.count_down
+      other_process.join
+    end
 end
 
 class ReservedWordsMigrationTest < ActiveRecord::TestCase
@@ -571,7 +773,7 @@ class ReservedWordsMigrationTest < ActiveRecord::TestCase
       connection.add_index :values, :value
       connection.remove_index :values, :column => :value
     end
-
+  ensure
     connection.drop_table :values rescue nil
   end
 end
@@ -583,11 +785,11 @@ class ExplicitlyNamedIndexMigrationTest < ActiveRecord::TestCase
       t.integer :value
     end
 
-    assert_nothing_raised ArgumentError do
+    assert_nothing_raised do
       connection.add_index :values, :value, name: 'a_different_name'
       connection.remove_index :values, column: :value, name: 'a_different_name'
     end
-
+  ensure
     connection.drop_table :values rescue nil
   end
 end
@@ -738,6 +940,8 @@ if ActiveRecord::Base.connection.supports_bulk_alter?
 end
 
 class CopyMigrationsTest < ActiveRecord::TestCase
+  include ActiveSupport::Testing::Stream
+
   def setup
   end
 
@@ -947,13 +1151,7 @@ class CopyMigrationsTest < ActiveRecord::TestCase
     ActiveRecord::Base.logger = old
   end
 
-  private
-
-  def quietly
-    silence_stream(STDOUT) do
-      silence_stream(STDERR) do
-        yield
-      end
-    end
+  def test_unknown_migration_version_should_raise_an_argument_error
+    assert_raise(ArgumentError) { ActiveRecord::Migration[1.0] }
   end
 end