ibm_db 3.0.5 → 4.0.0

data/test/cases/migration/change_schema_test - Copy.rb

@@ -1,448 +0,0 @@
-require 'cases/helper'
-
-module ActiveRecord
-  class Migration
-    class ChangeSchemaTest < ActiveRecord::TestCase
-      attr_reader :connection, :table_name
-
-      def setup
-        super
-        @connection = ActiveRecord::Base.connection
-        @table_name = :testings
-      end
-
-      teardown do
-        connection.drop_table :testings rescue nil
-        ActiveRecord::Base.primary_key_prefix_type = nil
-        ActiveRecord::Base.clear_cache!
-      end
-
-      def test_create_table_without_id
-        testing_table_with_only_foo_attribute do
-          assert_equal connection.columns(:testings).size, 1
-        end
-      end
-
-	  unless current_adapter?(:IBM_DBAdapter)
-      # 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 DB
-        def test_add_column_with_primary_key_attribute
-          testing_table_with_only_foo_attribute do
-            connection.add_column :testings, :id, :primary_key
-            assert_equal connection.columns(:testings).size, 2
-          end
-        end
-	  end
-
-      def test_create_table_adds_id
-        connection.create_table :testings do |t|
-          t.column :foo, :string
-        end
-
-        assert_equal %w(id foo), connection.columns(:testings).map(&:name)
-      end
-
-      def test_create_table_with_not_null_column
-        connection.create_table :testings do |t|
-          t.column :foo, :string, :null => false
-        end
-
-        assert_raises(ActiveRecord::StatementInvalid) do
-          connection.execute "insert into testings (foo) values (NULL)"
-        end
-      end
-
-      def test_create_table_with_defaults
-        # MySQL doesn't allow defaults on TEXT or BLOB columns.
-        mysql = current_adapter?(:MysqlAdapter, :Mysql2Adapter)
-
-        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
-        end
-
-        columns = connection.columns(:testings)
-        one = columns.detect { |c| c.name == "one" }
-        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
-
-        assert_equal "hello", one.default
-        assert_equal true, two.type_cast_from_database(two.default)
-        assert_equal false, three.type_cast_from_database(three.default)
-        assert_equal '1', four.default
-        assert_equal "hello", five.default unless mysql
-      end
-
-      if current_adapter?(:PostgreSQLAdapter)
-        def test_add_column_with_array
-          connection.create_table :testings
-          connection.add_column :testings, :foo, :string, :array => true
-
-          columns = connection.columns(:testings)
-          array_column = columns.detect { |c| c.name == "foo" }
-
-          assert array_column.array
-        end
-
-        def test_create_table_with_array_column
-          connection.create_table :testings do |t|
-            t.string :foo, :array => true
-          end
-
-          columns = connection.columns(:testings)
-          array_column = columns.detect { |c| c.name == "foo" }
-
-          assert array_column.array
-        end
-      end
-
-      def test_create_table_with_bigint
-        connection.create_table :testings do |t|
-          t.bigint :eight_int
-        end
-        columns = connection.columns(:testings)
-        eight   = columns.detect { |c| c.name == "eight_int"   }
-
-        if current_adapter?(:OracleAdapter)
-          assert_equal 'NUMBER(19)', eight.sql_type
-        elsif current_adapter?(:SQLite3Adapter)
-          assert_equal 'bigint', eight.sql_type
-        else
-          assert_equal :integer, eight.type
-          assert_equal 8, eight.limit
-        end
-      ensure
-        connection.drop_table :testings
-      end
-
-      def test_create_table_with_limits
-        connection.create_table :testings do |t|
-          t.column :foo, :string, :limit => 255
-
-          t.column :default_int, :integer
-
-          t.column :one_int,    :integer, :limit => 1
-          t.column :four_int,   :integer, :limit => 4
-          t.column :eight_int,  :integer, :limit => 8
-        end
-
-        columns = connection.columns(:testings)
-        foo = columns.detect { |c| c.name == "foo" }
-        assert_equal 255, foo.limit
-
-        default = columns.detect { |c| c.name == "default_int" }
-        one     = columns.detect { |c| c.name == "one_int"     }
-        four    = columns.detect { |c| c.name == "four_int"    }
-        eight   = columns.detect { |c| c.name == "eight_int"   }
-
-        if current_adapter?(:PostgreSQLAdapter)
-          assert_equal 'integer', default.sql_type
-          assert_equal 'smallint', one.sql_type
-          assert_equal 'integer', four.sql_type
-          assert_equal 'bigint', eight.sql_type
-        elsif current_adapter?(:MysqlAdapter, :Mysql2Adapter)
-          assert_match 'int(11)', default.sql_type
-          assert_match 'tinyint', one.sql_type
-          assert_match 'int', four.sql_type
-          assert_match 'bigint', eight.sql_type
-        elsif current_adapter?(:OracleAdapter)
-          assert_equal 'NUMBER(38)', default.sql_type
-          assert_equal 'NUMBER(1)', one.sql_type
-          assert_equal 'NUMBER(4)', four.sql_type
-          assert_equal 'NUMBER(8)', eight.sql_type
-        end
-      end
-
-      def test_create_table_with_primary_key_prefix_as_table_name_with_underscore
-        ActiveRecord::Base.primary_key_prefix_type = :table_name_with_underscore
-
-        connection.create_table :testings do |t|
-          t.column :foo, :string
-        end
-
-        assert_equal %w(testing_id foo), connection.columns(:testings).map(&:name)
-      end
-
-      def test_create_table_with_primary_key_prefix_as_table_name
-        ActiveRecord::Base.primary_key_prefix_type = :table_name
-
-        connection.create_table :testings do |t|
-          t.column :foo, :string
-        end
-
-        assert_equal %w(testingid foo), connection.columns(:testings).map(&:name)
-      end
-
-      def test_create_table_raises_when_redefining_primary_key_column
-        error = assert_raise(ArgumentError) do
-          connection.create_table :testings do |t|
-            t.column :id, :string
-          end
-        end
-
-        assert_equal "you can't redefine the primary key column 'id'. To define a custom primary key, pass { id: false } to create_table.", error.message
-      end
-
-      def test_create_table_raises_when_redefining_custom_primary_key_column
-        error = assert_raise(ArgumentError) do
-          connection.create_table :testings, primary_key: :testing_id do |t|
-            t.column :testing_id, :string
-          end
-        end
-
-        assert_equal "you can't redefine the primary key column 'testing_id'. To define a custom primary key, pass { id: false } to create_table.", error.message
-      end
-
-      def test_create_table_with_timestamps_should_create_datetime_columns
-        # FIXME: Remove the silence when we change the default `null` behavior
-        ActiveSupport::Deprecation.silence do
-          connection.create_table table_name do |t|
-            t.timestamps
-          end
-        end
-        created_columns = connection.columns(table_name)
-
-        created_at_column = created_columns.detect {|c| c.name == 'created_at' }
-        updated_at_column = created_columns.detect {|c| c.name == 'updated_at' }
-
-        assert created_at_column.null
-        assert updated_at_column.null
-      end
-
-      def test_create_table_with_timestamps_should_create_datetime_columns_with_options
-        connection.create_table table_name do |t|
-          t.timestamps :null => false
-        end
-        created_columns = connection.columns(table_name)
-
-        created_at_column = created_columns.detect {|c| c.name == 'created_at' }
-        updated_at_column = created_columns.detect {|c| c.name == 'updated_at' }
-
-        assert !created_at_column.null
-        assert !updated_at_column.null
-      end
-
-      def test_create_table_without_a_block
-        connection.create_table table_name
-      end
-
-      # Sybase, and SQLite3 will not allow you to add a NOT NULL
-      # column to a table without a default value.
-      unless current_adapter?(:SybaseAdapter, :SQLite3Adapter, :IBM_DBAdapter)
-        def test_add_column_not_null_without_default
-          connection.create_table :testings do |t|
-            t.column :foo, :string
-          end
-          connection.add_column :testings, :bar, :string, :null => false
-
-          assert_raise(ActiveRecord::StatementInvalid) do
-            connection.execute "insert into testings (foo, bar) values ('hello', NULL)"
-          end
-        end
-      end
-
-      def test_add_column_not_null_with_default
-        connection.create_table :testings do |t|
-          t.column :foo, :string
-        end
-
-        con = connection
-        connection.enable_identity_insert("testings", true) if current_adapter?(:SybaseAdapter)
-        connection.execute "insert into testings (#{con.quote_column_name('id')}, #{con.quote_column_name('foo')}) values (1, 'hello')"
-        connection.enable_identity_insert("testings", false) if current_adapter?(:SybaseAdapter)
-        assert_nothing_raised {connection.add_column :testings, :bar, :string, :null => false, :default => "default" }
-
-        assert_raises(ActiveRecord::StatementInvalid) do
-          unless current_adapter?(:OpenBaseAdapter)
-            connection.execute "insert into testings (#{con.quote_column_name('id')}, #{con.quote_column_name('foo')}, #{con.quote_column_name('bar')}) values (2, 'hello', NULL)"
-          else
-            connection.insert("INSERT INTO testings (#{con.quote_column_name('id')}, #{con.quote_column_name('foo')}, #{con.quote_column_name('bar')}) VALUES (2, 'hello', NULL)",
-                                     "Testing Insert","id",2)
-          end
-        end
-      end
-
-      def test_change_column_quotes_column_names
-        connection.create_table :testings do |t|
-          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
-
-        connection.change_column :testings, :select, :string, :limit => 10
-
-        # Oracle needs primary key value from sequence
-        if current_adapter?(:OracleAdapter)
-          connection.execute "insert into testings (id, #{connection.quote_column_name('select')}) values (testings_seq.nextval, '7 chars')"
-        else
-          connection.execute "insert into testings (#{connection.quote_column_name('select')}) values ('7 chars')"
-        end
-      end
-
-      def test_keeping_default_and_notnull_constraints_on_change
-        connection.create_table :testings do |t|
-          t.column :title, :string
-        end
-        person_klass = Class.new(ActiveRecord::Base)
-        person_klass.table_name = 'testings'
-
-        person_klass.connection.add_column "testings", "wealth", :integer, :null => false, :default => 99
-        person_klass.reset_column_information
-        assert_equal 99, person_klass.columns_hash["wealth"].default
-        assert_equal false, person_klass.columns_hash["wealth"].null
-        # Oracle needs primary key value from sequence
-        if current_adapter?(:OracleAdapter)
-          assert_nothing_raised {person_klass.connection.execute("insert into testings (id, title) values (testings_seq.nextval, 'tester')")}
-        else
-          assert_nothing_raised {person_klass.connection.execute("insert into testings (title) values ('tester')")}
-        end
-
-        # change column default to see that column doesn't lose its not null definition
-        person_klass.connection.change_column_default "testings", "wealth", 100
-        person_klass.reset_column_information
-        assert_equal 100, person_klass.columns_hash["wealth"].default
-        assert_equal false, person_klass.columns_hash["wealth"].null
-
-		if (!current_adapter?(:IBM_DBAdapter))
-          # rename column to see that column doesn't lose its not null and/or default definition
-          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
-
-        # change column
-        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
-          assert_equal false, person_klass.columns_hash["money"].null
-        else
-          person_klass.connection.change_column "testings", "wealth", :decimal, :precision => 15, :scale => 1,:null => false, :default => 1000
-          person_klass.reset_column_information
-          assert_equal 1000, person_klass.columns_hash["wealth"].default
-          assert_equal false, person_klass.columns_hash["wealth"].null
-        end
-
-        # change column, make it nullable and clear default
-        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
-          assert_equal true, person_klass.columns_hash["money"].null
-         else
-          person_klass.connection.change_column "testings", "wealth", :decimal, :precision => 20, :scale => 2,  :null => true, :default => nil
-          person_klass.reset_column_information
-          assert_nil person_klass.columns_hash["wealth"].default
-          assert_equal true, person_klass.columns_hash["wealth"].null
-        end
-
-        # change_column_null, make it not nullable and set null values to a default value
-        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
-          assert_nil person_klass.columns_hash["money"].default
-          assert_equal false, person_klass.columns_hash["money"].null
-          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 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
-          #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
-      end
-
-      def test_change_column_null
-        testing_table_with_only_foo_attribute do
-          notnull_migration = Class.new(ActiveRecord::Migration) do
-            def change
-              change_column_null :testings, :foo, false
-            end
-          end
-          notnull_migration.new.suppress_messages do
-            notnull_migration.migrate(:up)
-            assert_equal false, connection.columns(:testings).find{ |c| c.name == "foo"}.null
-            notnull_migration.migrate(:down)
-            assert connection.columns(:testings).find{ |c| c.name == "foo"}.null
-          end
-        end
-      end
-
-      def test_column_exists
-        connection.create_table :testings do |t|
-          t.column :foo, :string
-        end
-
-        assert connection.column_exists?(:testings, :foo)
-        assert_not connection.column_exists?(:testings, :bar)
-      end
-
-      def test_column_exists_with_type
-        connection.create_table :testings do |t|
-          t.column :foo, :string
-          t.column :bar, :decimal, :precision => 8, :scale => 2
-        end
-
-        assert connection.column_exists?(:testings, :foo, :string)
-        assert_not connection.column_exists?(:testings, :foo, :integer)
-
-        assert connection.column_exists?(:testings, :bar, :decimal)
-        assert_not connection.column_exists?(:testings, :bar, :integer)
-      end
-
-      def test_column_exists_with_definition
-        connection.create_table :testings do |t|
-          t.column :foo, :string, limit: 100
-          t.column :bar, :decimal, precision: 8, scale: 2
-          t.column :taggable_id, :integer, null: false
-          t.column :taggable_type, :string, default: 'Photo'
-        end
-
-        assert connection.column_exists?(:testings, :foo, :string, limit: 100)
-        assert_not connection.column_exists?(:testings, :foo, :string, limit: nil)
-        assert connection.column_exists?(:testings, :bar, :decimal, precision: 8, scale: 2)
-        assert_not connection.column_exists?(:testings, :bar, :decimal, precision: nil, scale: nil)
-        assert connection.column_exists?(:testings, :taggable_id, :integer, null: false)
-        assert_not connection.column_exists?(:testings, :taggable_id, :integer, null: true)
-        assert connection.column_exists?(:testings, :taggable_type, :string, default: 'Photo')
-        assert_not connection.column_exists?(:testings, :taggable_type, :string, default: nil)
-      end
-
-      def test_column_exists_on_table_with_no_options_parameter_supplied
-        connection.create_table :testings do |t|
-          t.string :foo
-        end
-        connection.change_table :testings do |t|
-          assert t.column_exists?(:foo)
-          assert !(t.column_exists?(:bar))
-        end
-      end
-
-      private
-      def testing_table_with_only_foo_attribute
-        connection.create_table :testings, :id => false do |t|
-          t.column :foo, :string
-        end
-
-        yield
-      end
-    end
-  end
-end

data/test/cases/migration/foreign_key_test - Changed.rb

@@ -1,325 +0,0 @@
-require 'cases/helper'
-require 'support/ddl_helper'
-require 'support/schema_dumping_helper'
-
-if ActiveRecord::Base.connection.supports_foreign_keys?
-module ActiveRecord
-  class Migration
-    class ForeignKeyTest < ActiveRecord::TestCase
-      include DdlHelper
-      include SchemaDumpingHelper
-
-      class Rocket < ActiveRecord::Base
-      end
-
-      class Astronaut < ActiveRecord::Base
-      end
-
-      setup do
-        @connection = ActiveRecord::Base.connection
-        @connection.create_table "rockets", force: true do |t|
-          t.string :name
-        end
-
-        @connection.create_table "astronauts", force: true do |t|
-          t.string :name
-          t.references :rocket
-        end
-      end
-
-
-      teardown do
-        if defined?(@connection)
-          #@connection.drop_table "astronauts" if @connection.table_exists? 'astronauts' 
-          #@connection.drop_table "rockets" if @connection.table_exists? 'rockets'
-        end
-      end
-
-      def test_foreign_keys
-        foreign_keys = @connection.foreign_keys("fk_test_has_fk")
-        assert_equal 1, foreign_keys.size
-
-        fk = foreign_keys.first
-		if current_adapter?(:IBM_DBAdapter)
-			assert_equal "fk_test_has_fk".upcase, fk.from_table.upcase
-			assert_equal "fk_test_has_pk".upcase, fk.to_table.upcase
-		else
-			assert_equal "fk_test_has_fk", fk.from_table
-			assert_equal "fk_test_has_pk", fk.to_table
-		end
-        
-        assert_equal "fk_id", fk.column
-        assert_equal "pk_id", fk.primary_key
-        assert_equal "fk_name", fk.name
-      end
-
-      def test_add_foreign_key_inferes_column
-        @connection.add_foreign_key :astronauts, :rockets
-
-        foreign_keys = @connection.foreign_keys("astronauts")
-        assert_equal 1, foreign_keys.size
-
-        fk = foreign_keys.first
-		if current_adapter?(:IBM_DBAdapter)
-			assert_equal "astronauts".upcase, fk.from_table.upcase			
-		else
-			assert_equal "astronauts", fk.from_table
-		end
-        assert_equal "rockets", fk.to_table
-        assert_equal "rocket_id", fk.column
-        assert_equal "id", fk.primary_key
-        assert_equal("fk_rails_78146ddd2e", fk.name)
-      end
-
-      def test_add_foreign_key_with_column
-        @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id"
-
-        foreign_keys = @connection.foreign_keys("astronauts")
-        assert_equal 1, foreign_keys.size
-
-        fk = foreign_keys.first
-		if current_adapter?(:IBM_DBAdapter)
-			assert_equal "astronauts".upcase, fk.from_table.upcase
-		else
-			assert_equal "astronauts", fk.from_table
-		end
-        assert_equal "rockets", fk.to_table
-        assert_equal "rocket_id", fk.column
-        assert_equal "id", fk.primary_key
-        assert_equal("fk_rails_78146ddd2e", fk.name)
-      end
-
-      def test_add_foreign_key_with_non_standard_primary_key	    
-		#@connection.create_table :space_shuttles, force: true, id: false do |t|
-        #  t.primary_key :pk
-        #end
-        with_example_table @connection, "space_shuttles", "pk integer PRIMARY KEY" do
-          @connection.add_foreign_key(:astronauts, :space_shuttles,
-                                      column: "rocket_id", primary_key: "pk", name: "custom_pk")
-
-          foreign_keys = @connection.foreign_keys("astronauts")
-          assert_equal 1, foreign_keys.size
-
-          fk = foreign_keys.first
-		  if current_adapter?(:IBM_DBAdapter)
-			assert_equal "astronauts".upcase, fk.from_table.upcase
-		  else
-			assert_equal "astronauts", fk.from_table
-		  end
-          assert_equal "space_shuttles", fk.to_table
-          assert_equal "pk", fk.primary_key
-
-          @connection.remove_foreign_key :astronauts, name: "custom_pk"
-        end
-      end
-
-      def test_add_on_delete_restrict_foreign_key
-        @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", on_delete: :restrict
-
-        foreign_keys = @connection.foreign_keys("astronauts")
-        assert_equal 1, foreign_keys.size
-
-        fk = foreign_keys.first
-        if current_adapter?(:MysqlAdapter, :Mysql2Adapter)
-          # ON DELETE RESTRICT is the default on MySQL
-          assert_equal "noaction", fk.on_delete
-        elsif current_adapter?(:IBM_DBAdapter)
-			assert_equal :noaction, fk.on_update		
-		else 
-          assert_equal :restrict, fk.on_delete
-        end
-      end
-
-      def test_add_on_delete_cascade_foreign_key
-        @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", on_delete: :cascade
-
-        foreign_keys = @connection.foreign_keys("astronauts")
-        assert_equal 1, foreign_keys.size
-
-        fk = foreign_keys.first
-		
-		if current_adapter?(:IBM_DBAdapter)
-			assert_equal :noaction, fk.on_update		
-		else 
-			assert_equal :cascade, fk.on_delete
-		end
-        
-      end
-
-      def test_add_on_delete_nullify_foreign_key
-        @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", on_delete: :nullify
-
-        foreign_keys = @connection.foreign_keys("astronauts")
-        assert_equal 1, foreign_keys.size
-
-        fk = foreign_keys.first
-		
-		if current_adapter?(:IBM_DBAdapter)
-			assert_equal :noaction, fk.on_update		
-		else 
-			assert_equal :nullify, fk.on_delete
-		end
-        
-      end
-
-      def test_on_update_and_on_delete_raises_with_invalid_values
-        assert_raises ArgumentError do
-          @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", on_delete: :invalid
-        end
-
-        assert_raises ArgumentError do
-          @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", on_update: :invalid
-        end
-      end
-
-      def test_add_foreign_key_with_on_update
-        #@connection.add_foreign_key :astronauts, :rockets, column: "rocket_id" , on_update: :nullify
-		@connection.add_foreign_key :astronauts, :rockets, column: "rocket_id"
-
-        foreign_keys = @connection.foreign_keys("astronauts")
-        assert_equal 1, foreign_keys.size
-
-        fk = foreign_keys.first
-		
-		if current_adapter?(:IBM_DBAdapter)
-			assert_equal :noaction, fk.on_update		
-		else 
-			assert_equal :nullify, fk.on_update		
-		end
-		
-      end
-
-      def test_remove_foreign_key_inferes_column
-        @connection.add_foreign_key :astronauts, :rockets
-
-        assert_equal 1, @connection.foreign_keys("astronauts").size
-        @connection.remove_foreign_key :astronauts, :rockets
-        assert_equal [], @connection.foreign_keys("astronauts")
-      end
-
-      def test_remove_foreign_key_by_column
-        @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id"
-
-        assert_equal 1, @connection.foreign_keys("astronauts").size
-        @connection.remove_foreign_key :astronauts, column: "rocket_id"
-        assert_equal [], @connection.foreign_keys("astronauts")
-      end
-
-      def test_remove_foreign_key_by_symbol_column
-        @connection.add_foreign_key :astronauts, :rockets, column: :rocket_id
-
-        assert_equal 1, @connection.foreign_keys("astronauts").size
-        @connection.remove_foreign_key :astronauts, column: :rocket_id
-        assert_equal [], @connection.foreign_keys("astronauts")
-      end
-
-      def test_remove_foreign_key_by_name
-        @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", name: "fancy_named_fk"
-
-        assert_equal 1, @connection.foreign_keys("astronauts").size
-        @connection.remove_foreign_key :astronauts, name: "fancy_named_fk"
-        assert_equal [], @connection.foreign_keys("astronauts")
-      end
-
-      def test_remove_foreign_non_existing_foreign_key_raises
-        assert_raises ArgumentError do
-          @connection.remove_foreign_key :astronauts, :rockets
-        end
-      end
-
-      def test_schema_dumping
-        @connection.add_foreign_key :astronauts, :rockets
-        output = dump_table_schema "astronauts"
-        assert_match %r{\s+add_foreign_key "astronauts", "rockets"$}, output
-      end
-
-      def test_schema_dumping_with_options
-        output = dump_table_schema "fk_test_has_fk"
-        assert_match %r{\s+add_foreign_key "fk_test_has_fk", "fk_test_has_pk", column: "fk_id", primary_key: "pk_id", name: "fk_name"$}, output
-      end
-
-      def test_schema_dumping_on_delete_and_on_update_options
-        #@connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", on_delete: :nullify, on_update: :cascade
-		@connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", on_delete: :nullify, on_update: :restrict
-
-        output = dump_table_schema "astronauts"
-        #assert_match %r{\s+add_foreign_key "astronauts",.+on_update: :cascade,.+on_delete: :nullify$}, output
-		assert_match %r{\s+add_foreign_key "astronauts",.+on_update: :restrict,.+on_delete: :nullify$}, output
-      end
-
-      class CreateCitiesAndHousesMigration < ActiveRecord::Migration
-        def change
-          create_table("cities") { |t| }
-
-          create_table("houses") do |t|
-            t.column :city_id, :integer
-          end
-          add_foreign_key :houses, :cities, column: "city_id"
-        end
-      end
-
-      def test_add_foreign_key_is_reversible
-        migration = CreateCitiesAndHousesMigration.new
-        silence_stream($stdout) { migration.migrate(:up) }
-        assert_equal 1, @connection.foreign_keys("houses").size
-      ensure
-        silence_stream($stdout) { migration.migrate(:down) }
-      end
-      class CreateSchoolsAndClassesMigration < ActiveRecord::Migration
-        def change
-          create_table(:schools)
-
-          create_table(:classes) do |t|
-            t.column :school_id, :integer
-          end
-          add_foreign_key :classes, :schools
-        end
-      end
-
-      def test_add_foreign_key_with_prefix
-        ActiveRecord::Base.table_name_prefix = 'p_'
-        migration = CreateSchoolsAndClassesMigration.new
-        silence_stream($stdout) { migration.migrate(:up) }
-        assert_equal 1, @connection.foreign_keys("p_classes").size
-      ensure
-        silence_stream($stdout) { migration.migrate(:down) }
-        ActiveRecord::Base.table_name_prefix = nil
-      end
-
-      def test_add_foreign_key_with_suffix
-        ActiveRecord::Base.table_name_suffix = '_s'
-        migration = CreateSchoolsAndClassesMigration.new
-        silence_stream($stdout) { migration.migrate(:up) }
-        assert_equal 1, @connection.foreign_keys("classes_s").size
-      ensure
-        silence_stream($stdout) { migration.migrate(:down) }
-        ActiveRecord::Base.table_name_suffix = nil
-      end
-    end
-  end
-end
-else
-module ActiveRecord
-  class Migration
-    class NoForeignKeySupportTest < ActiveRecord::TestCase
-      setup do
-        @connection = ActiveRecord::Base.connection
-      end
-
-      def test_add_foreign_key_should_be_noop
-        @connection.add_foreign_key :clubs, :categories
-      end
-
-      def test_remove_foreign_key_should_be_noop
-        @connection.remove_foreign_key :clubs, :categories
-      end
-
-      def test_foreign_keys_should_raise_not_implemented
-        assert_raises NotImplementedError do
-          @connection.foreign_keys("clubs")
-        end
-      end
-    end
-  end
-end
-end