ibm_db 3.0.4-x86-mingw32 → 5.0.4-x86-mingw32

data/test/cases/migration/logger_test.rb

@@ -1,36 +1,36 @@
-require "cases/helper"
-
-module ActiveRecord
-  class Migration
-    class LoggerTest < ActiveRecord::TestCase
-      # MySQL can't roll back ddl changes
-      self.use_transactional_fixtures = false
-
-      Migration = Struct.new(:name, :version) do
-        def disable_ddl_transaction; false end
-        def migrate direction
-          # do nothing
-        end
-      end
-
-      def setup
-        super
-        ActiveRecord::SchemaMigration.create_table
-        ActiveRecord::SchemaMigration.delete_all
-      end
-
-      teardown do
-        ActiveRecord::SchemaMigration.drop_table
-      end
-
-      def test_migration_should_be_run_without_logger
-        previous_logger = ActiveRecord::Base.logger
-        ActiveRecord::Base.logger = nil
-        migrations = [Migration.new('a', 1), Migration.new('b', 2), Migration.new('c', 3)]
-        ActiveRecord::Migrator.new(:up, migrations).migrate
-      ensure
-        ActiveRecord::Base.logger = previous_logger
-      end
-    end
-  end
-end
+require "cases/helper"
+
+module ActiveRecord
+  class Migration
+    class LoggerTest < ActiveRecord::TestCase
+      # MySQL can't roll back ddl changes
+      self.use_transactional_tests = false
+
+      Migration = Struct.new(:name, :version) do
+        def disable_ddl_transaction; false end
+        def migrate direction
+          # do nothing
+        end
+      end
+
+      def setup
+        super
+        ActiveRecord::SchemaMigration.create_table
+        ActiveRecord::SchemaMigration.delete_all
+      end
+
+      teardown do
+        ActiveRecord::SchemaMigration.drop_table
+      end
+
+      def test_migration_should_be_run_without_logger
+        previous_logger = ActiveRecord::Base.logger
+        ActiveRecord::Base.logger = nil
+        migrations = [Migration.new('a', 1), Migration.new('b', 2), Migration.new('c', 3)]
+        ActiveRecord::Migrator.new(:up, migrations).migrate
+      ensure
+        ActiveRecord::Base.logger = previous_logger
+      end
+    end
+  end
+end

data/test/cases/migration/pending_migrations_test.rb

@@ -1,53 +1,52 @@
-require 'cases/helper'
-require "minitest/mock"
-
-module ActiveRecord
-  class Migration
-    class PendingMigrationsTest < ActiveRecord::TestCase
-      def setup
-        super
-        @connection = Minitest::Mock.new
-        @app = Minitest::Mock.new
-        conn = @connection
-        @pending = Class.new(CheckPending) {
-          define_method(:connection) { conn }
-        }.new(@app)
-        @pending.instance_variable_set :@last_check, -1 # Force checking
-      end
-
-      def teardown
-        assert @connection.verify
-        assert @app.verify
-        super
-      end
-
-      def test_errors_if_pending
-        @connection.expect :supports_migrations?, true
-
-        ActiveRecord::Migrator.stub :needs_migration?, true do
-          assert_raise ActiveRecord::PendingMigrationError do
-            @pending.call(nil)
-          end
-        end
-      end
-
-      def test_checks_if_supported
-        @connection.expect :supports_migrations?, true
-        @app.expect :call, nil, [:foo]
-
-        ActiveRecord::Migrator.stub :needs_migration?, false do
-          @pending.call(:foo)
-        end
-      end
-
-      def test_doesnt_check_if_unsupported
-        @connection.expect :supports_migrations?, false
-        @app.expect :call, nil, [:foo]
-
-        ActiveRecord::Migrator.stub :needs_migration?, true do
-          @pending.call(:foo)
-        end
-      end
-    end
-  end
-end
+require 'cases/helper'
+
+module ActiveRecord
+  class Migration
+    class PendingMigrationsTest < ActiveRecord::TestCase
+      def setup
+        super
+        @connection = Minitest::Mock.new
+        @app = Minitest::Mock.new
+        conn = @connection
+        @pending = Class.new(CheckPending) {
+          define_method(:connection) { conn }
+        }.new(@app)
+        @pending.instance_variable_set :@last_check, -1 # Force checking
+      end
+
+      def teardown
+        assert @connection.verify
+        assert @app.verify
+        super
+      end
+
+      def test_errors_if_pending
+        @connection.expect :supports_migrations?, true
+
+        ActiveRecord::Migrator.stub :needs_migration?, true do
+          assert_raise ActiveRecord::PendingMigrationError do
+            @pending.call(nil)
+          end
+        end
+      end
+
+      def test_checks_if_supported
+        @connection.expect :supports_migrations?, true
+        @app.expect :call, nil, [:foo]
+
+        ActiveRecord::Migrator.stub :needs_migration?, false do
+          @pending.call(:foo)
+        end
+      end
+
+      def test_doesnt_check_if_unsupported
+        @connection.expect :supports_migrations?, false
+        @app.expect :call, nil, [:foo]
+
+        ActiveRecord::Migrator.stub :needs_migration?, true do
+          @pending.call(:foo)
+        end
+      end
+    end
+  end
+end

data/test/cases/migration/references_foreign_key_test.rb

@@ -1,214 +1,221 @@
-require 'cases/helper'
-
-if ActiveRecord::Base.connection.supports_foreign_keys?
-module ActiveRecord
-  class Migration
-    class ReferencesForeignKeyTest < ActiveRecord::TestCase
-
-	
-      setup do
-        @connection = ActiveRecord::Base.connection
-        
-      end
-
-	  
-      teardown do
-        @connection.drop_table("testings") if @connection.table_exists? "testings"
-        @connection.drop_table("testing_parents") if @connection.table_exists? "testing_parents"
-      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
-        
-      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|
-          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)
-        @connection.create_table :testings do |t|
-          assert_raises(ArgumentError) do
-            t.references :testing_parent, polymorphic: true, foreign_key: true
-          end
-        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
-        @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|
-          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)
-        @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
-
-      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)
-        @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
-
-      test "foreign key methods respect pluralize_table_names" do
-        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_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
-        end
-      end
-    end
-  end
-end
-else
-class ReferencesWithoutForeignKeySupportTest < ActiveRecord::TestCase
-  setup do
-    @connection = ActiveRecord::Base.connection
-    @connection.create_table(:testing_parents, force: true)
-  end
-
-  teardown do
-    @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
-    @connection.create_table :testings do |t|
-      t.references :testing_parent, foreign_key: true
-    end
-
-    assert_includes @connection.tables, "testings"
-  end
-end
-end
+require 'cases/helper'
+
+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_exists: true
+        @connection.drop_table "testing_parents"
+		#, if_exists: 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
+        end
+
+        fk = @connection.foreign_keys("testings").first
+        assert_equal "testings", fk.from_table
+        assert_equal "testing_parents", fk.to_table
+      end
+
+      test "no foreign key is created by default" do
+        @connection.create_table :testings do |t|
+          t.references :testing_parent
+        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
+          @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
+
+        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
+          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
+        end
+
+        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.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
+
+        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
+
+      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
+
+      test "foreign key methods respect pluralize_table_names" do
+        begin
+          original_pluralize_table_names = ActiveRecord::Base.pluralize_table_names
+          ActiveRecord::Base.pluralize_table_names = false
+          @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
+          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
+        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
+else
+class ReferencesWithoutForeignKeySupportTest < ActiveRecord::TestCase
+  setup do
+    @connection = ActiveRecord::Base.connection
+    @connection.create_table(:testing_parents, force: true)
+  end
+
+  teardown do
+    @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
+    @connection.create_table :testings do |t|
+      t.references :testing_parent, foreign_key: true
+    end
+
+    assert_includes @connection.data_sources, "testings"
+  end
+end
+end