ibm_db 5.1.0-x86-mingw32 → 5.3.2-x86-mingw32

data/test/cases/migration/references_foreign_key_test.rb

@@ -1,132 +1,155 @@
-require 'cases/helper'
+# frozen_string_literal: true
 
-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
+require "cases/helper"
 
-      teardown do
-        @connection.drop_table "testings"
-		#, if_exists: true
-        @connection.drop_table "testing_parents"
-		#, if_exists: true
-      end
+if ActiveRecord::Base.connection.supports_foreign_keys?
+  module ActiveRecord
+    class Migration
+      class ReferencesForeignKeyInCreateTest < ActiveRecord::TestCase
+        setup do
+          @connection = ActiveRecord::Base.connection
+          @connection.create_table(:testing_parents, force: true)
+        end
 
-      test "foreign keys can be created with the table" do
-        @connection.create_table :testings do |t|
-          t.references :testing_parent, foreign_key: true
+        teardown do
+          @connection.drop_table "testings", if_exists: true
+          @connection.drop_table "testing_parents", if_exists: true
         end
 
-        fk = @connection.foreign_keys("testings").first
-        assert_equal "testings", fk.from_table
-        assert_equal "testing_parents", fk.to_table
-      end
+        test "foreign keys can be created with the table" do
+          @connection.create_table :testings do |t|
+            t.references :testing_parent, foreign_key: true
+          end
 
-      test "no foreign key is created by default" do
-        @connection.create_table :testings do |t|
-          t.references :testing_parent
+          fk = @connection.foreign_keys("testings").first
+          assert_equal "testings", fk.from_table
+          assert_equal "testing_parents", fk.to_table
         end
 
-        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
+        test "no foreign key is created by default" do
           @connection.create_table :testings do |t|
-            t.references :testing_parent, foreign_key: true, index: false
+            t.references :testing_parent
           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
+          assert_equal [], @connection.foreign_keys("testings")
         end
-        @connection.create_table :testings do |t|
-          t.references :testing_parent, foreign_key: { primary_key: :other_id }
+
+        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
 
-        fk = @connection.foreign_keys("testings").find { |k| k.to_table == "testing_parents" }
-        assert_equal "other_id", fk.primary_key
-      end
+        test "options hash can be passed" do
+          @connection.change_table :testing_parents do |t|
+            t.references :other, index: { unique: true }
+          end
+          @connection.create_table :testings do |t|
+            t.references :testing_parent, foreign_key: { primary_key: :other_id }
+          end
 
-      test "to_table option can be passed" do
-        @connection.create_table :testings do |t|
-          t.references :parent, foreign_key: { to_table: :testing_parents }
+          fk = @connection.foreign_keys("testings").find { |k| k.to_table == "testing_parents" }
+          assert_equal "other_id", fk.primary_key
         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
+        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
       end
+    end
+  end
 
-      test "foreign keys can be created while changing the table" do
-        @connection.create_table :testings
-        @connection.change_table :testings do |t|
-          t.references :testing_parent, foreign_key: true
+  module ActiveRecord
+    class Migration
+      class ReferencesForeignKeyTest < ActiveRecord::TestCase
+        setup do
+          @connection = ActiveRecord::Base.connection
+          @connection.create_table(:testing_parents, force: true)
         end
 
-        fk = @connection.foreign_keys("testings").first
-        assert_equal "testings", fk.from_table
-        assert_equal "testing_parents", fk.to_table
-      end
+        teardown do
+          @connection.drop_table "testings", if_exists: true
+          @connection.drop_table "testing_parents", if_exists: true
+        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
+        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
+            end
+          end
         end
 
-        assert_equal [], @connection.foreign_keys("testings")
-      end
+        test "foreign keys can be created while changing the table" do
+          @connection.create_table :testings
+          @connection.change_table :testings do |t|
+            t.references :testing_parent, foreign_key: true
+          end
 
-      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
+          fk = @connection.foreign_keys("testings").first
+          assert_equal "testings", fk.from_table
+          assert_equal "testing_parents", fk.to_table
         end
-        @connection.create_table :testings
-        @connection.change_table :testings do |t|
-          t.references :testing_parent, foreign_key: { primary_key: :other_id }
+
+        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
 
-        fk = @connection.foreign_keys("testings").find { |k| k.to_table == "testing_parents" }
-        assert_equal "other_id", fk.primary_key
-      end
+        test "foreign keys accept options when changing the table" do
+          @connection.change_table :testing_parents do |t|
+            t.references :other, index: { unique: true }
+          end
+          @connection.create_table :testings
+          @connection.change_table :testings do |t|
+            t.references :testing_parent, foreign_key: { primary_key: :other_id }
+          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
-            t.references :testing_parent, polymorphic: true, foreign_key: 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
+              t.references :testing_parent, polymorphic: true, foreign_key: true
+            end
           end
         end
-      end
 
-      test "foreign key column can be removed" do
-        @connection.create_table :testings do |t|
-          t.references :testing_parent, index: true, foreign_key: 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
+
+          assert_difference "@connection.foreign_keys('testings').size", -1 do
+            @connection.remove_reference :testings, :testing_parent, foreign_key: true
+          end
         end
 
-        assert_difference "@connection.foreign_keys('testings').size", -1 do
-          @connection.remove_reference :testings, :testing_parent, foreign_key: true
+        test "removing column removes foreign key" do
+          @connection.create_table :testings do |t|
+            t.references :testing_parent, index: true, foreign_key: true
+          end
+
+          assert_difference "@connection.foreign_keys('testings').size", -1 do
+            @connection.remove_column :testings, :testing_parent_id
+          end
         end
-      end
 
-      test "foreign key methods respect pluralize_table_names" do
-        begin
+        test "foreign key methods respect pluralize_table_names" do
           original_pluralize_table_names = ActiveRecord::Base.pluralize_table_names
           ActiveRecord::Base.pluralize_table_names = false
           @connection.create_table :testing
@@ -143,79 +166,70 @@ 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
+        class CreateDogsMigration < ActiveRecord::Migration::Current
+          def change
+            create_table :dog_owners
 
-          create_table :dogs do |t|
-            t.references :dog_owner, foreign_key: true
+            create_table :dogs do |t|
+              t.references :dog_owner, foreign_key: true
+            end
           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_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
+        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.references :parent1, foreign_key: { to_table: :testing_parents }
+            t.references :parent2, foreign_key: { to_table: :testing_parents }
+            t.references :self_join, foreign_key: { to_table: :testings }
+          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
+          fks = @connection.foreign_keys("testings").sort_by(&:column)
 
-          t.foreign_key :testing_parents, column: :col_1
-          t.foreign_key :testing_parents, column: :col_2
+          fk_definitions = fks.map { |fk| [fk.from_table, fk.to_table, fk.column] }
+          assert_equal([["testings", "testing_parents", "parent1_id"],
+                        ["testings", "testing_parents", "parent2_id"],
+                        ["testings", "testings", "self_join_id"]], fk_definitions)
         end
 
-        fks = @connection.foreign_keys("testings")
+        test "multiple foreign keys can be removed to the selected one" do
+          @connection.create_table :testings do |t|
+            t.references :parent1, foreign_key: { to_table: :testing_parents }
+            t.references :parent2, foreign_key: { to_table: :testing_parents }
+          end
 
-        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
-else
-class ReferencesWithoutForeignKeySupportTest < ActiveRecord::TestCase
-  setup do
-    @connection = ActiveRecord::Base.connection
-    @connection.create_table(:testing_parents, force: true)
-  end
+          assert_difference "@connection.foreign_keys('testings').size", -1 do
+            @connection.remove_reference :testings, :parent1, foreign_key: { to_table: :testing_parents }
+          end
 
-  teardown do
-    @connection.drop_table("testings")
-	#, if_exists: true)
-    @connection.drop_table("testing_parents")
-	#, if_exists: true)
-  end
+          fks = @connection.foreign_keys("testings").sort_by(&:column)
 
-  test "ignores foreign keys defined with the table" do
-    @connection.create_table :testings do |t|
-      t.references :testing_parent, foreign_key: true
+          fk_definitions = fks.map { |fk| [fk.from_table, fk.to_table, fk.column] }
+          assert_equal([["testings", "testing_parents", "parent2_id"]], fk_definitions)
+        end
+      end
     end
-
-    assert_includes @connection.data_sources, "testings"
   end
 end
-end

data/test/cases/migration/references_index_test.rb

@@ -1,4 +1,6 @@
-require 'cases/helper'
+# frozen_string_literal: true
+
+require "cases/helper"
 
 module ActiveRecord
   class Migration
@@ -17,10 +19,10 @@ module ActiveRecord
 
       def test_creates_index
         connection.create_table table_name do |t|
-          t.references :foo, :index => true
+          t.references :foo, index: true
         end
 
-        assert 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_creates_index_by_default_even_if_index_option_is_not_passed
@@ -28,44 +30,52 @@ module ActiveRecord
           t.references :foo
         end
 
-        assert 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
         connection.create_table table_name do |t|
-          t.references :foo, :index => false
+          t.references :foo, index: false
         end
 
-        assert_not connection.index_exists?(table_name, :foo_id, :name => :index_testings_on_foo_id)
+        assert_not connection.index_exists?(table_name, :foo_id, name: :index_testings_on_foo_id)
       end
 
       def test_creates_index_with_options
         connection.create_table table_name do |t|
-          t.references :foo, :index => {:name => :index_testings_on_yo_momma}
-          t.references :bar, :index => {:unique => true}
+          t.references :foo, index: { name: :index_testings_on_yo_momma }
+          t.references :bar, index: { unique: true }
         end
 
-        assert connection.index_exists?(table_name, :foo_id, :name => :index_testings_on_yo_momma)
-        assert connection.index_exists?(table_name, :bar_id, :name => :index_testings_on_bar_id, :unique => true)
+        assert connection.index_exists?(table_name, :foo_id, name: :index_testings_on_yo_momma)
+        assert connection.index_exists?(table_name, :bar_id, name: :index_testings_on_bar_id, unique: true)
       end
 
       unless current_adapter? :OracleAdapter
         def test_creates_polymorphic_index
           connection.create_table table_name do |t|
-            t.references :foo, :polymorphic => true, :index => true
+            t.references :foo, polymorphic: true, index: true
+          end
+
+          assert connection.index_exists?(table_name, [:foo_type, :foo_id], name: :index_testings_on_foo)
+        end
+
+        def test_creates_polymorphic_index_with_custom_name
+          connection.create_table table_name do |t|
+            t.references :foo, polymorphic: true, index: { name: :testings_foo_index }
           end
 
-          assert connection.index_exists?(table_name, [:foo_type, :foo_id], name: :index_testings_on_foo_type_and_foo_id)
+          assert connection.index_exists?(table_name, [:foo_type, :foo_id], name: :testings_foo_index)
         end
       end
 
       def test_creates_index_for_existing_table
         connection.create_table table_name
         connection.change_table table_name do |t|
-          t.references :foo, :index => true
+          t.references :foo, index: true
         end
 
-        assert 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_creates_index_for_existing_table_even_if_index_option_is_not_passed
@@ -74,26 +84,35 @@ module ActiveRecord
           t.references :foo
         end
 
-        assert 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
         connection.create_table table_name
         connection.change_table table_name do |t|
-          t.references :foo, :index => false
+          t.references :foo, index: false
         end
 
-        assert_not connection.index_exists?(table_name, :foo_id, :name => :index_testings_on_foo_id)
+        assert_not connection.index_exists?(table_name, :foo_id, name: :index_testings_on_foo_id)
       end
 
       unless current_adapter? :OracleAdapter
         def test_creates_polymorphic_index_for_existing_table
           connection.create_table table_name
           connection.change_table table_name do |t|
-            t.references :foo, :polymorphic => true, :index => true
+            t.references :foo, polymorphic: true, index: true
+          end
+
+          assert connection.index_exists?(table_name, [:foo_type, :foo_id], name: :index_testings_on_foo)
+        end
+
+        def test_creates_polymorphic_index_for_existing_table_with_custom_name
+          connection.create_table table_name
+          connection.change_table table_name do |t|
+            t.references :foo, polymorphic: true, index: { name: :testings_foo_index }
           end
 
-          assert connection.index_exists?(table_name, [:foo_type, :foo_id], name: :index_testings_on_foo_type_and_foo_id)
+          assert connection.index_exists?(table_name, [:foo_type, :foo_id], name: :testings_foo_index)
         end
       end
     end

data/test/cases/migration/references_statements_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/migration/helper"
 
 module ActiveRecord
@@ -35,7 +37,7 @@ module ActiveRecord
         assert_not index_exists?(table_name, :user_id)
       end
 
-      def test_create_reference_id_index_even_if_index_option_is_passed
+      def test_create_reference_id_index_even_if_index_option_is_not_passed
         add_reference table_name, :user
         assert index_exists?(table_name, :user_id)
       end
@@ -46,8 +48,8 @@ module ActiveRecord
       end
 
       def test_creates_reference_type_column_with_default
-        add_reference table_name, :taggable, polymorphic: { default: 'Photo' }, index: true
-        assert column_exists?(table_name, :taggable_type, :string, default: 'Photo')
+        add_reference table_name, :taggable, polymorphic: { default: "Photo" }, index: true
+        assert column_exists?(table_name, :taggable_type, :string, default: "Photo")
       end
 
       def test_creates_reference_type_column_with_not_null
@@ -60,19 +62,19 @@ module ActiveRecord
 
       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_id, :integer)
         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')
+        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 )
+        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
@@ -124,13 +126,12 @@ module ActiveRecord
       end
 
       private
+        def with_polymorphic_column
+          add_column table_name, :supplier_type, :string
+          add_index table_name, [:supplier_id, :supplier_type]
 
-      def with_polymorphic_column
-        add_column table_name, :supplier_type, :string
-        add_index table_name, [:supplier_id, :supplier_type]
-
-        yield
-      end
+          yield
+        end
     end
   end
 end