ibm_db 3.0.3 → 5.0.3

data/test/cases/migration/create_join_table_test.rb

@@ -12,7 +12,9 @@ module ActiveRecord
 
       teardown do
         %w(artists_musics musics_videos catalog).each do |table_name|
-          connection.drop_table table_name if connection.tables.include?(table_name)
+          ActiveSupport::Deprecation.silence do
+            connection.drop_table table_name if connection.table_exists?(table_name)
+          end
         end
       end
 
@@ -82,65 +84,72 @@ module ActiveRecord
         connection.create_join_table :artists, :musics
         connection.drop_join_table :artists, :musics
 
-        assert !connection.tables.include?('artists_musics')
+        ActiveSupport::Deprecation.silence { assert !connection.table_exists?('artists_musics') }
       end
 
       def test_drop_join_table_with_strings
         connection.create_join_table :artists, :musics
         connection.drop_join_table 'artists', 'musics'
 
-        assert !connection.tables.include?('artists_musics')
+        ActiveSupport::Deprecation.silence { assert !connection.table_exists?('artists_musics') }
       end
 
       def test_drop_join_table_with_the_proper_order
         connection.create_join_table :videos, :musics
         connection.drop_join_table :videos, :musics
 
-        assert !connection.tables.include?('musics_videos')
+        ActiveSupport::Deprecation.silence { assert !connection.table_exists?('musics_videos') }
       end
 
       def test_drop_join_table_with_the_table_name
         connection.create_join_table :artists, :musics, table_name: :catalog
         connection.drop_join_table :artists, :musics, table_name: :catalog
 
-        assert !connection.tables.include?('catalog')
+        ActiveSupport::Deprecation.silence { assert !connection.table_exists?('catalog') }
       end
 
       def test_drop_join_table_with_the_table_name_as_string
         connection.create_join_table :artists, :musics, table_name: 'catalog'
         connection.drop_join_table :artists, :musics, table_name: 'catalog'
 
-        assert !connection.tables.include?('catalog')
+        ActiveSupport::Deprecation.silence { assert !connection.table_exists?('catalog') }
       end
 
       def test_drop_join_table_with_column_options
         connection.create_join_table :artists, :musics, column_options: {null: true}
         connection.drop_join_table :artists, :musics, column_options: {null: true}
 
-        assert !connection.tables.include?('artists_musics')
+        ActiveSupport::Deprecation.silence { assert !connection.table_exists?('artists_musics') }
       end
 
       def test_create_and_drop_join_table_with_common_prefix
         with_table_cleanup do
           connection.create_join_table 'audio_artists', 'audio_musics'
-          assert_includes connection.tables, 'audio_artists_musics'
+          ActiveSupport::Deprecation.silence { assert connection.table_exists?('audio_artists_musics') }
 
           connection.drop_join_table 'audio_artists', 'audio_musics'
-          assert !connection.tables.include?('audio_artists_musics'), "Should have dropped join table, but didn't"
+          ActiveSupport::Deprecation.silence { assert !connection.table_exists?('audio_artists_musics'), "Should have dropped join table, but didn't" }
+        end
+      end
+
+      if current_adapter?(:PostgreSQLAdapter)
+        def test_create_join_table_with_uuid
+          connection.create_join_table :artists, :musics, column_options: { type: :uuid }
+          assert_equal [:uuid, :uuid], connection.columns(:artists_musics).map(&:type)
         end
       end
 
       private
 
         def with_table_cleanup
-          tables_before = connection.tables
+          tables_before = connection.data_sources
 
           yield
         ensure
-          tables_after = connection.tables - tables_before
+          tables_after = connection.data_sources - tables_before
 
           tables_after.each do |table|
-            connection.execute "DROP TABLE #{table}"
+            connection.drop_table table
           end
         end
     end

data/test/cases/migration/foreign_key_test.rb

@@ -6,8 +6,9 @@ if ActiveRecord::Base.connection.supports_foreign_keys?
 module ActiveRecord
   class Migration
     class ForeignKeyTest < ActiveRecord::TestCase
-     include DdlHelper
-     include SchemaDumpingHelper
+      include DdlHelper
+      include SchemaDumpingHelper
+      include ActiveSupport::Testing::Stream
 
       class Rocket < ActiveRecord::Base
       end
@@ -15,7 +16,7 @@ module ActiveRecord
       class Astronaut < ActiveRecord::Base
       end
 
-      setup do	    
+      setup do
         @connection = ActiveRecord::Base.connection
         @connection.create_table "rockets", force: true do |t|
           t.string :name
@@ -24,18 +25,18 @@ module ActiveRecord
         @connection.create_table "astronauts", force: true do |t|
           t.string :name
           t.references :rocket
-        end			
+        end
       end
-	  	  
 
-      teardown do	    
+      teardown do
         if defined?(@connection)
-          @connection.drop_table "astronauts" if @connection.table_exists? 'astronauts' 
-          @connection.drop_table "rockets" if @connection.table_exists? 'rockets'
+          @connection.drop_table "astronauts"
+		  #, if_exists: true
+          @connection.drop_table "rockets"
+		  #, if_exists: true
         end
       end
 
-
       def test_foreign_keys
         foreign_keys = @connection.foreign_keys("fk_test_has_fk")
         assert_equal 1, foreign_keys.size
@@ -56,9 +57,8 @@ module ActiveRecord
 		end        
       end
 
-
-      def test_add_foreign_key_inferes_column	  		        
-        @connection.add_foreign_key :astronauts, :rockets		
+      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
@@ -85,8 +85,6 @@ module ActiveRecord
         
       end
 
-	  
-
       def test_add_foreign_key_with_column
         @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id"
 
@@ -110,7 +108,7 @@ module ActiveRecord
                 
       end
 
-      def test_add_foreign_key_with_non_standard_primary_key	  
+      def test_add_foreign_key_with_non_standard_primary_key
 		if current_adapter?(:IBM_DBAdapter)
 			@connection.create_table :space_shuttles, force: true, id: false do |t|
 			t.primary_key :pk
@@ -136,7 +134,7 @@ module ActiveRecord
 			assert_equal "pk", fk.primary_key		  
 			@connection.remove_foreign_key :astronauts, name: "custom_pk"
 			end		
-		end		
+        end
       end
 
       def test_add_on_delete_restrict_foreign_key
@@ -146,12 +144,10 @@ module ActiveRecord
         assert_equal 1, foreign_keys.size
 
         fk = foreign_keys.first
-        if current_adapter?(:MysqlAdapter, :Mysql2Adapter)
+        if current_adapter?(: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_delete		
-		else 
+          assert_equal nil, fk.on_delete
+        else
           assert_equal :restrict, fk.on_delete
         end
       end
@@ -162,13 +158,8 @@ module ActiveRecord
         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_delete		
-		else 
-			assert_equal :cascade, fk.on_delete
-		end
-        
+        fk = foreign_keys.first
+        assert_equal :cascade, fk.on_delete
       end
 
       def test_add_on_delete_nullify_foreign_key
@@ -178,13 +169,7 @@ module ActiveRecord
         assert_equal 1, foreign_keys.size
 
         fk = foreign_keys.first
-		
-		if current_adapter?(:IBM_DBAdapter)
-			assert_equal :noaction, fk.on_delete		
-		else 
-			assert_equal :nullify, fk.on_delete
-		end
-        
+        assert_equal :nullify, fk.on_delete
       end
 
       def test_on_update_and_on_delete_raises_with_invalid_values
@@ -198,18 +183,34 @@ module ActiveRecord
       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"
+        @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", on_update: :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_update		
-		end
+        assert_equal :nullify, fk.on_update
+      end
+
+      def test_foreign_key_exists
+        @connection.add_foreign_key :astronauts, :rockets
+
+        assert @connection.foreign_key_exists?(:astronauts, :rockets)
+        assert_not @connection.foreign_key_exists?(:astronauts, :stars)
+      end
+
+      def test_foreign_key_exists_by_column
+        @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id"
+
+        assert @connection.foreign_key_exists?(:astronauts, column: "rocket_id")
+        assert_not @connection.foreign_key_exists?(:astronauts, column: "star_id")
+      end
+
+      def test_foreign_key_exists_by_name
+        @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", name: "fancy_named_fk"
+
+        assert @connection.foreign_key_exists?(:astronauts, name: "fancy_named_fk")
+        assert_not @connection.foreign_key_exists?(:astronauts, name: "other_fancy_named_fk")
       end
 
       def test_remove_foreign_key_inferes_column
@@ -230,17 +231,10 @@ module ActiveRecord
 
       def test_remove_foreign_key_by_symbol_column
         @connection.add_foreign_key :astronauts, :rockets, column: :rocket_id
-		
-		if current_adapter?(:IBM_DBAdapter)			
-			foreign_keys = @connection.foreign_keys("astronauts")
-			assert_equal 1, foreign_keys.size											
-			@connection.remove_foreign_key "astronauts".upcase, column: "rocket_id".upcase
-		else
-			assert_equal 1, @connection.foreign_keys("astronauts").size
-			@connection.remove_foreign_key :astronauts, column: :rocket_id
-		end
-        
-		assert_equal [], @connection.foreign_keys("astronauts")
+
+        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
@@ -264,22 +258,18 @@ module ActiveRecord
       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		
+        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
-	    if current_adapter?(:IBM_DBAdapter)
-			@connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", on_delete: :nullify, on_update: :restrict
-		else
-			@connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", on_delete: :nullify, on_update: :cascade
-		end
-		
-		output = dump_table_schema "astronauts"
-		assert_match %r{\s+add_foreign_key "astronauts",.+on_update: :restrict,.+on_delete: :nullify$}, output		
+        @connection.add_foreign_key :astronauts, :rockets, column: "rocket_id", on_delete: :nullify, on_update: :cascade
+
+        output = dump_table_schema "astronauts"
+        assert_match %r{\s+add_foreign_key "astronauts",.+on_update: :cascade,.+on_delete: :nullify$}, output
       end
 
-      class CreateCitiesAndHousesMigration < ActiveRecord::Migration
+      class CreateCitiesAndHousesMigration < ActiveRecord::Migration::Current
         def change
           create_table("cities") { |t| }
 
@@ -287,6 +277,10 @@ module ActiveRecord
             t.column :city_id, :integer
           end
           add_foreign_key :houses, :cities, column: "city_id"
+
+          # remove and re-add to test that schema is updated and not accidently cached
+          remove_foreign_key :houses, :cities
+          add_foreign_key :houses, :cities, column: "city_id", on_delete: :cascade
         end
       end
 
@@ -298,7 +292,16 @@ module ActiveRecord
         silence_stream($stdout) { migration.migrate(:down) }
       end
 
-      class CreateSchoolsAndClassesMigration < ActiveRecord::Migration
+      def test_foreign_key_constraint_is_not_cached_incorrectly
+        migration = CreateCitiesAndHousesMigration.new
+        silence_stream($stdout) { migration.migrate(:up) }
+        output = dump_table_schema "houses"
+        assert_match %r{\s+add_foreign_key "houses",.+on_delete: :cascade$}, output
+      ensure
+        silence_stream($stdout) { migration.migrate(:down) }
+      end
+
+      class CreateSchoolsAndClassesMigration < ActiveRecord::Migration::Current
         def change
           create_table(:schools)
 
@@ -328,7 +331,6 @@ module ActiveRecord
         silence_stream($stdout) { migration.migrate(:down) }
         ActiveRecord::Base.table_name_suffix = nil
       end
-	  
 
     end
   end

data/test/cases/migration/index_test.rb

@@ -9,12 +9,8 @@ module ActiveRecord
         super
         @connection = ActiveRecord::Base.connection
         @table_name = :testings
-		
-		if current_adapter?(:IBM_DBAdapter)
-			connection.drop_table :testings rescue nil
-		end
-        
-		connection.create_table table_name do |t|
+
+        connection.create_table table_name do |t|
           t.column :foo, :string, :limit => 100
           t.column :bar, :string, :limit => 100
 
@@ -62,11 +58,7 @@ module ActiveRecord
       end
 
       def test_remove_nonexistent_index
-		if current_adapter?(:IBM_DBAdapter)
-			assert_raise(ArgumentError) { connection.remove_index(table_name, "no_such_index") }
-		else
-			assert_raise(ArgumentError) { connection.remove_index(table_name, "no_such_index") }
-		end
+        assert_raise(ArgumentError) { connection.remove_index(table_name, "no_such_index") }
       end
 
       def test_add_index_works_with_long_index_names
@@ -138,7 +130,17 @@ module ActiveRecord
       def test_named_index_exists
         connection.add_index :testings, :foo, :name => "custom_index_name"
 
+        assert connection.index_exists?(:testings, :foo)
         assert connection.index_exists?(:testings, :foo, :name => "custom_index_name")
+        assert !connection.index_exists?(:testings, :foo, :name => "other_index_name")
+      end
+
+      def test_remove_named_index
+        connection.add_index :testings, :foo, :name => "custom_index_name"
+
+        assert connection.index_exists?(:testings, :foo)
+        connection.remove_index :testings, :foo
+        assert !connection.index_exists?(:testings, :foo)
       end
 
       def test_add_index_attribute_length_limit
@@ -184,7 +186,7 @@ module ActiveRecord
         connection.remove_index("testings", :name => "named_admin")
 
         # Selected adapters support index sort order
-        if current_adapter?(:SQLite3Adapter, :MysqlAdapter, :Mysql2Adapter, :PostgreSQLAdapter)
+        if current_adapter?(:SQLite3Adapter, :Mysql2Adapter, :PostgreSQLAdapter)
           connection.add_index("testings", ["last_name"], :order => {:last_name => :desc})
           connection.remove_index("testings", ["last_name"])
           connection.add_index("testings", ["last_name", "first_name"], :order => {:last_name => :desc})

data/test/cases/migration/logger_test.rb

@@ -4,7 +4,7 @@ module ActiveRecord
   class Migration
     class LoggerTest < ActiveRecord::TestCase
       # MySQL can't roll back ddl changes
-      self.use_transactional_fixtures = false
+      self.use_transactional_tests = false
 
       Migration = Struct.new(:name, :version) do
         def disable_ddl_transaction; false end

data/test/cases/migration/pending_migrations_test.rb

@@ -1,5 +1,4 @@
 require 'cases/helper'
-require "minitest/mock"
 
 module ActiveRecord
   class Migration

data/test/cases/migration/references_foreign_key_test.rb

@@ -4,74 +4,67 @@ if ActiveRecord::Base.connection.supports_foreign_keys?
 module ActiveRecord
   class Migration
     class ReferencesForeignKeyTest < ActiveRecord::TestCase
-
-	
       setup do
         @connection = ActiveRecord::Base.connection
-        
+        @connection.create_table(:testing_parents, force: true)
       end
 
-	  
       teardown do
-        @connection.drop_table("testings") if @connection.table_exists? "testings"
-        @connection.drop_table("testing_parents") if @connection.table_exists? "testing_parents"
+        @connection.drop_table "testings"
+		#, if_exists: true
+        @connection.drop_table "testing_parents"
+		#, if_exists: true
       end
 
-	  
       test "foreign keys can be created with the table" do
-		@connection.drop_table("testings") if @connection.table_exists? "testings"
-        @connection.drop_table("testing_parents") if @connection.table_exists? "testing_parents"
-	    @connection.create_table(:testing_parents, force: true)
         @connection.create_table :testings do |t|
           t.references :testing_parent, foreign_key: true
         end
 
         fk = @connection.foreign_keys("testings").first
-		if current_adapter?(:IBM_DBAdapter)
-			assert_equal "testings".upcase, fk.from_table.upcase
-			assert_equal "testing_parents".upcase, fk.to_table.upcase
-		else
-			assert_equal "testings", fk.from_table
-			assert_equal "testing_parents", fk.to_table
-		end
-        
+        assert_equal "testings", fk.from_table
+        assert_equal "testing_parents", fk.to_table
       end
 
-      
       test "no foreign key is created by default" do
-		@connection.drop_table("testings") if @connection.table_exists? "testings"
-        @connection.drop_table("testing_parents") if @connection.table_exists? "testing_parents"
-		@connection.create_table(:testing_parents, force: true)
         @connection.create_table :testings do |t|
           t.references :testing_parent
         end
 
         assert_equal [], @connection.foreign_keys("testings")
       end
-	  
-	        
-      test "options hash can be passed" do	    
-		@connection.drop_table("testings") if @connection.table_exists? "testings"
-        @connection.drop_table("testing_parents") if @connection.table_exists? "testing_parents"
-		@connection.create_table :testing_parents, primary_key: 'other_id'              
-		@connection.create_table :testings do |t|
+
+      test "foreign keys can be created in one query when index is not added" do
+        assert_queries(1) do
+          @connection.create_table :testings do |t|
+            t.references :testing_parent, foreign_key: true, index: false
+          end
+        end
+      end
+
+      test "options hash can be passed" do
+        @connection.change_table :testing_parents do |t|
+          t.integer :other_id
+          t.index :other_id, unique: true
+        end
+        @connection.create_table :testings do |t|
           t.references :testing_parent, foreign_key: { primary_key: :other_id }
         end
-        
-		if current_adapter?(:IBM_DBAdapter)
-			fk = @connection.foreign_keys("TESTINGS").find { |k| k.to_table == "TESTING_PARENTS" }		
-			assert_equal "OTHER_ID", fk.primary_key
-		else	
-			fk = @connection.foreign_keys("testings").find { |k| k.to_table == "testing_parents" }		
-			assert_equal "other_id", fk.primary_key
-		end
-      end	  
-
-      
-      test "foreign keys cannot be added to polymorphic relations when creating the table" do	    
-		@connection.drop_table("testings") if @connection.table_exists? "testings"
-        @connection.drop_table("testing_parents") if @connection.table_exists? "testing_parents"
-		@connection.create_table(:testing_parents, force: true)
+
+        fk = @connection.foreign_keys("testings").find { |k| k.to_table == "testing_parents" }
+        assert_equal "other_id", fk.primary_key
+      end
+
+      test "to_table option can be passed" do
+        @connection.create_table :testings do |t|
+          t.references :parent, foreign_key: { to_table: :testing_parents }
+        end
+        fks = @connection.foreign_keys("testings")
+        assert_equal([["testings", "testing_parents", "parent_id"]],
+                     fks.map {|fk| [fk.from_table, fk.to_table, fk.column] })
+      end
+
+      test "foreign keys cannot be added to polymorphic relations when creating the table" do
         @connection.create_table :testings do |t|
           assert_raises(ArgumentError) do
             t.references :testing_parent, polymorphic: true, foreign_key: true
@@ -79,66 +72,41 @@ module ActiveRecord
         end
       end
 
-      
       test "foreign keys can be created while changing the table" do
-        @connection.drop_table("testings") if @connection.table_exists? "testings"
-        @connection.drop_table("testing_parents") if @connection.table_exists? "testing_parents"	  
-		@connection.create_table(:testing_parents, force: true)
         @connection.create_table :testings
         @connection.change_table :testings do |t|
           t.references :testing_parent, foreign_key: true
         end
 
-        fk = @connection.foreign_keys("testings").first		
-		
-		if current_adapter?(:IBM_DBAdapter)
-			assert_equal "testings".upcase, fk.from_table.upcase
-			assert_equal "testing_parents".upcase, fk.to_table.upcase
-		else
-			assert_equal "testings", fk.from_table
-			assert_equal "testing_parents", fk.to_table
-		end
-        
-      end
-
-      
-      test "foreign keys are not added by default when changing the table" do 
-        @connection.drop_table("testings") if @connection.table_exists? "testings"
-        @connection.drop_table("testing_parents") if @connection.table_exists? "testing_parents"	  
-		@connection.create_table(:testing_parents, force: true)
-		@connection.create_table :testings
+        fk = @connection.foreign_keys("testings").first
+        assert_equal "testings", fk.from_table
+        assert_equal "testing_parents", fk.to_table
+      end
+
+      test "foreign keys are not added by default when changing the table" do
+        @connection.create_table :testings
         @connection.change_table :testings do |t|
           t.references :testing_parent
         end
 
         assert_equal [], @connection.foreign_keys("testings")
       end
-	  
-	 
-      test "foreign keys accept options when changing the table" do		
-	    @connection.drop_table("testings") if @connection.table_exists? "testings"
-        @connection.drop_table("testing_parents") if @connection.table_exists? "testing_parents"		
-		@connection.create_table :testing_parents, primary_key: 'other_id'         
-        
-		@connection.create_table :testings        
-		@connection.change_table :testings do |t|
+
+      test "foreign keys accept options when changing the table" do
+        @connection.change_table :testing_parents do |t|
+          t.integer :other_id
+          t.index :other_id, unique: true
+        end
+        @connection.create_table :testings
+        @connection.change_table :testings do |t|
           t.references :testing_parent, foreign_key: { primary_key: :other_id }
         end
-		
-		if current_adapter?(:IBM_DBAdapter)
-			fk = @connection.foreign_keys("TESTINGS").find { |k| k.to_table == "TESTING_PARENTS" }			
-			assert_equal "OTHER_ID", fk.primary_key
-		else
-			fk = @connection.foreign_keys("testings").find { |k| k.to_table == "testing_parents" }		
-			assert_equal "other_id", fk.primary_key		
-        end		
-      end
-
-	  
-      test "foreign keys cannot be added to polymorphic relations when changing the table" do	 
-		@connection.drop_table("testings") if @connection.table_exists? "testings"
-        @connection.drop_table("testing_parents") if @connection.table_exists? "testing_parents"
-		@connection.create_table(:testing_parents, force: true)
+
+        fk = @connection.foreign_keys("testings").find { |k| k.to_table == "testing_parents" }
+        assert_equal "other_id", fk.primary_key
+      end
+
+      test "foreign keys cannot be added to polymorphic relations when changing the table" do
         @connection.create_table :testings
         @connection.change_table :testings do |t|
           assert_raises(ArgumentError) do
@@ -147,10 +115,7 @@ module ActiveRecord
         end
       end
 
-      test "foreign key column can be removed" do	    
-	    @connection.drop_table("testings") if @connection.table_exists? "testings"
-        @connection.drop_table("testing_parents") if @connection.table_exists? "testing_parents"
-		@connection.create_table(:testing_parents, force: true)
+      test "foreign key column can be removed" do
         @connection.create_table :testings do |t|
           t.references :testing_parent, index: true, foreign_key: true
         end
@@ -164,30 +129,70 @@ module ActiveRecord
         begin
           original_pluralize_table_names = ActiveRecord::Base.pluralize_table_names
           ActiveRecord::Base.pluralize_table_names = false
-		  @connection.drop_table("testing") if @connection.table_exists? "testing"
           @connection.create_table :testing
           @connection.change_table :testing_parents do |t|
             t.references :testing, foreign_key: true
           end
 
           fk = @connection.foreign_keys("testing_parents").first
-		  if current_adapter?(:IBM_DBAdapter)
-			assert_equal "testing_parents".upcase, fk.from_table.upcase
-			assert_equal "testing".upcase, fk.to_table.upcase
-		  else
-			assert_equal "testing_parents", fk.from_table
-			assert_equal "testing", fk.to_table
-		  end
-          
+          assert_equal "testing_parents", fk.from_table
+          assert_equal "testing", fk.to_table
 
           assert_difference "@connection.foreign_keys('testing_parents').size", -1 do
             @connection.remove_reference :testing_parents, :testing, foreign_key: true
           end
         ensure
           ActiveRecord::Base.pluralize_table_names = original_pluralize_table_names
-          @connection.drop_table "testing", if_exists: true
+          @connection.drop_table "testing"
+		  #, if_exists: true
         end
       end
+
+      class CreateDogsMigration < ActiveRecord::Migration::Current
+        def change
+          create_table :dog_owners
+
+          create_table :dogs do |t|
+            t.references :dog_owner, foreign_key: true
+          end
+        end
+      end
+
+      def test_references_foreign_key_with_prefix
+        ActiveRecord::Base.table_name_prefix = 'p_'
+        migration = CreateDogsMigration.new
+        silence_stream($stdout) { migration.migrate(:up) }
+        assert_equal 1, @connection.foreign_keys("p_dogs").size
+      ensure
+        silence_stream($stdout) { migration.migrate(:down) }
+        ActiveRecord::Base.table_name_prefix = nil
+      end
+
+      def test_references_foreign_key_with_suffix
+        ActiveRecord::Base.table_name_suffix = '_s'
+        migration = CreateDogsMigration.new
+        silence_stream($stdout) { migration.migrate(:up) }
+        assert_equal 1, @connection.foreign_keys("dogs_s").size
+      ensure
+        silence_stream($stdout) { migration.migrate(:down) }
+        ActiveRecord::Base.table_name_suffix = nil
+      end
+
+      test "multiple foreign keys can be added to the same table" do
+        @connection.create_table :testings do |t|
+          t.integer :col_1
+          t.integer :col_2
+
+          t.foreign_key :testing_parents, column: :col_1
+          t.foreign_key :testing_parents, column: :col_2
+        end
+
+        fks = @connection.foreign_keys("testings")
+
+        fk_definitions = fks.map {|fk| [fk.from_table, fk.to_table, fk.column] }
+        assert_equal([["testings", "testing_parents", "col_1"],
+                      ["testings", "testing_parents", "col_2"]], fk_definitions)
+      end
     end
   end
 end
@@ -199,8 +204,10 @@ class ReferencesWithoutForeignKeySupportTest < ActiveRecord::TestCase
   end
 
   teardown do
-    @connection.drop_table("testings", if_exists: true)
-    @connection.drop_table("testing_parents", if_exists: true)
+    @connection.drop_table("testings")
+	#, if_exists: true)
+    @connection.drop_table("testing_parents")
+	#, if_exists: true)
   end
 
   test "ignores foreign keys defined with the table" do
@@ -208,7 +215,7 @@ class ReferencesWithoutForeignKeySupportTest < ActiveRecord::TestCase
       t.references :testing_parent, foreign_key: true
     end
 
-    assert_includes @connection.tables, "testings"
+    assert_includes @connection.data_sources, "testings"
   end
 end
 end