ibm_db 3.0.5-x86-mingw32 → 5.0.5-x86-mingw32

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

@@ -8,6 +8,7 @@ module ActiveRecord
     class ForeignKeyTest < ActiveRecord::TestCase
       include DdlHelper
       include SchemaDumpingHelper
+      include ActiveSupport::Testing::Stream
 
       class Rocket < ActiveRecord::Base
       end
@@ -29,8 +30,10 @@ module ActiveRecord
 
       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
 
@@ -141,10 +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 nil, fk.on_delete
-		else 
+        else
           assert_equal :restrict, fk.on_delete
         end
       end
@@ -155,8 +158,8 @@ module ActiveRecord
         foreign_keys = @connection.foreign_keys("astronauts")
         assert_equal 1, foreign_keys.size
 
-        fk = foreign_keys.first		
-        assert_equal :cascade, fk.on_delete		
+        fk = foreign_keys.first
+        assert_equal :cascade, fk.on_delete
       end
 
       def test_add_on_delete_nullify_foreign_key
@@ -180,15 +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
-        assert_equal :noaction, fk.on_update
-		#assert_equal nil, fk.on_update
+        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
@@ -232,24 +254,22 @@ module ActiveRecord
       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
+        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
+        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: :cascade, on_update: :restrict
+        @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
-		assert_match %r{\s+add_foreign_key "ASTRONAUTS",.+on_update: :restrict,.+on_delete: :cascade$}, output
+        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| }
 
@@ -257,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
 
@@ -268,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)
 
@@ -298,6 +331,7 @@ module ActiveRecord
         silence_stream($stdout) { migration.migrate(:down) }
         ActiveRecord::Base.table_name_suffix = nil
       end
+
     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

@@ -10,8 +10,10 @@ module ActiveRecord
       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
@@ -32,6 +34,14 @@ module ActiveRecord
         assert_equal [], @connection.foreign_keys("testings")
       end
 
+      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
@@ -45,6 +55,15 @@ module ActiveRecord
         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
@@ -124,10 +143,41 @@ module ActiveRecord
           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
@@ -137,7 +187,7 @@ module ActiveRecord
           t.foreign_key :testing_parents, column: :col_2
         end
 
-        fks = @connection.foreign_keys("testings").sort_by(&:column)
+        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"],
@@ -154,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
@@ -163,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

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