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

data/test/cases/integration_test.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
 
-require 'cases/helper'
-require 'models/company'
-require 'models/developer'
-require 'models/computer'
-require 'models/owner'
-require 'models/pet'
+require "cases/helper"
+require "models/company"
+require "models/developer"
+require "models/computer"
+require "models/owner"
+require "models/pet"
 
 class IntegrationTest < ActiveRecord::TestCase
   fixtures :companies, :developers, :owners, :pets
@@ -15,59 +16,85 @@ class IntegrationTest < ActiveRecord::TestCase
 
   def test_to_param_returns_nil_if_not_persisted
     client = Client.new
-    assert_equal nil, client.to_param
+    assert_nil client.to_param
   end
 
   def test_to_param_returns_id_if_not_persisted_but_id_is_set
     client = Client.new
     client.id = 1
-    assert_equal '1', client.to_param
+    assert_equal "1", client.to_param
   end
 
   def test_to_param_class_method
     firm = Firm.find(4)
-    assert_equal '4-flamboyant-software', firm.to_param
+    assert_equal "4-flamboyant-software", firm.to_param
+  end
+
+  def test_to_param_class_method_truncates_words_properly
+    firm = Firm.find(4)
+    firm.name << ", Inc."
+    assert_equal "4-flamboyant-software", firm.to_param
+  end
+
+  def test_to_param_class_method_truncates_after_parameterize
+    firm = Firm.find(4)
+    firm.name = "Huey, Dewey, & Louie LLC"
+    #               123456789T123456789v
+    assert_equal "4-huey-dewey-louie-llc", firm.to_param
+  end
+
+  def test_to_param_class_method_truncates_after_parameterize_with_hyphens
+    firm = Firm.find(4)
+    firm.name = "Door-to-Door Wash-n-Fold Service"
+    #               123456789T123456789v
+    assert_equal "4-door-to-door-wash-n", firm.to_param
   end
 
   def test_to_param_class_method_truncates
     firm = Firm.find(4)
-    firm.name = 'a ' * 100
-    assert_equal '4-a-a-a-a-a-a-a-a-a', firm.to_param
+    firm.name = "a " * 100
+    assert_equal "4-a-a-a-a-a-a-a-a-a-a", firm.to_param
   end
 
   def test_to_param_class_method_truncates_edge_case
     firm = Firm.find(4)
-    firm.name = 'David HeinemeierHansson'
-    assert_equal '4-david', firm.to_param
+    firm.name = "David HeinemeierHansson"
+    assert_equal "4-david", firm.to_param
+  end
+
+  def test_to_param_class_method_truncates_case_shown_in_doc
+    firm = Firm.find(4)
+    firm.name = "David Heinemeier Hansson"
+    assert_equal "4-david-heinemeier", firm.to_param
   end
 
   def test_to_param_class_method_squishes
     firm = Firm.find(4)
     firm.name = "ab \n" * 100
-    assert_equal '4-ab-ab-ab-ab-ab-ab', firm.to_param
+    assert_equal "4-ab-ab-ab-ab-ab-ab-ab", firm.to_param
   end
 
   def test_to_param_class_method_multibyte_character
     firm = Firm.find(4)
     firm.name = "戦場ヶ原 ひたぎ"
-    assert_equal '4', firm.to_param
+    assert_equal "4", firm.to_param
   end
 
   def test_to_param_class_method_uses_default_if_blank
     firm = Firm.find(4)
     firm.name = nil
-    assert_equal '4', firm.to_param
-    firm.name = ' '
-    assert_equal '4', firm.to_param
+    assert_equal "4", firm.to_param
+    firm.name = " "
+    assert_equal "4", firm.to_param
   end
 
   def test_to_param_class_method_uses_default_if_not_persisted
-    firm = Firm.new(name: 'Fancy Shirts')
-    assert_equal nil, firm.to_param
+    firm = Firm.new(name: "Fancy Shirts")
+    assert_nil firm.to_param
   end
 
   def test_to_param_with_no_arguments
-    assert_equal 'Firm', Firm.to_param
+    assert_equal "Firm", Firm.to_param
   end
 
   def test_cache_key_for_existing_record_is_not_timezone_dependent
@@ -127,29 +154,90 @@ class IntegrationTest < ActiveRecord::TestCase
   end
 
   def test_cache_key_format_is_precise_enough
-    skip("Subsecond precision is not supported") unless subsecond_precision_supported?
+    skip("Subsecond precision is not supported") unless supports_datetime_with_precision?
     dev = Developer.first
     key = dev.cache_key
-    dev.touch
+    travel_to dev.updated_at + 0.000001 do
+      dev.touch
+    end
     assert_not_equal key, dev.cache_key
   end
 
   def test_cache_key_format_is_not_too_precise
-    skip("Subsecond precision is not supported") unless subsecond_precision_supported?
     dev = Developer.first
     dev.touch
     key = dev.cache_key
     assert_equal key, dev.reload.cache_key
   end
 
-  def test_named_timestamps_for_cache_key
-    owner = owners(:blackbeard)
-    assert_equal "owners/#{owner.id}-#{owner.happy_at.utc.to_s(:usec)}", owner.cache_key(:updated_at, :happy_at)
+  def test_cache_version_format_is_precise_enough
+    skip("Subsecond precision is not supported") unless supports_datetime_with_precision?
+    with_cache_versioning do
+      dev = Developer.first
+      version = dev.cache_version.to_param
+      travel_to Developer.first.updated_at + 0.000001 do
+        dev.touch
+      end
+      assert_not_equal version, dev.cache_version.to_param
+    end
   end
 
-  def test_cache_key_when_named_timestamp_is_nil
-    owner = owners(:blackbeard)
-    owner.happy_at = nil
-    assert_equal "owners/#{owner.id}", owner.cache_key(:happy_at)
+  def test_cache_version_format_is_not_too_precise
+    with_cache_versioning do
+      dev = Developer.first
+      dev.touch
+      key = dev.cache_version.to_param
+      assert_equal key, dev.reload.cache_version.to_param
+    end
+  end
+
+  def test_cache_key_is_stable_with_versioning_on
+    with_cache_versioning do
+      developer = Developer.first
+      first_key = developer.cache_key
+
+      developer.touch
+      second_key = developer.cache_key
+
+      assert_equal first_key, second_key
+    end
+  end
+
+  def test_cache_version_changes_with_versioning_on
+    with_cache_versioning do
+      developer     = Developer.first
+      first_version = developer.cache_version
+
+      travel 10.seconds do
+        developer.touch
+      end
+
+      second_version = developer.cache_version
+
+      assert_not_equal first_version, second_version
+    end
+  end
+
+  def test_cache_key_retains_version_when_custom_timestamp_is_used
+    with_cache_versioning do
+      developer = Developer.first
+      first_key = developer.cache_key_with_version
+
+      travel 10.seconds do
+        developer.touch
+      end
+
+      second_key = developer.cache_key_with_version
+
+      assert_not_equal first_key, second_key
+    end
+  end
+
+  def with_cache_versioning(value = true)
+    @old_cache_versioning = ActiveRecord::Base.cache_versioning
+    ActiveRecord::Base.cache_versioning = value
+    yield
+  ensure
+    ActiveRecord::Base.cache_versioning = @old_cache_versioning
   end
 end

data/test/cases/invalid_connection_test.rb

@@ -1,24 +1,26 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
-if current_adapter?(:Mysql2Adapter)
-class TestAdapterWithInvalidConnection < ActiveRecord::TestCase
-  self.use_transactional_tests = false
+if current_adapter?(:Mysql2Adapter) or current_adapter?(:IBM_DBAdapter)
+  class TestAdapterWithInvalidConnection < ActiveRecord::TestCase
+    self.use_transactional_tests = false
 
-  class Bird < ActiveRecord::Base
-  end
+    class Bird < ActiveRecord::Base
+    end
 
-  def setup
-    # Can't just use current adapter; sqlite3 will create a database
-    # file on the fly.
-    Bird.establish_connection adapter: 'mysql2', database: 'i_do_not_exist'
-  end
+    def setup
+      # Can't just use current adapter; sqlite3 will create a database
+      # file on the fly.
+      Bird.establish_connection adapter: "ibm_db", database: "i_do_not_exist"
+    end
 
-  teardown do
-    Bird.remove_connection
-  end
+    teardown do
+      Bird.remove_connection
+    end
 
-  test "inspect on Model class does not raise" do
-    assert_equal "#{Bird.name} (call '#{Bird.name}.connection' to establish a connection)", Bird.inspect
+    test "inspect on Model class does not raise" do
+      assert_equal "#{Bird.name} (call '#{Bird.name}.connection' to establish a connection)", Bird.inspect
+    end
   end
 end
-end

data/test/cases/invertible_migration_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "cases/helper"
 
 class Horse < ActiveRecord::Base
@@ -6,7 +8,7 @@ end
 module ActiveRecord
   class InvertibleMigrationTest < ActiveRecord::TestCase
     class SilentMigration < ActiveRecord::Migration::Current
-      def write(text = '')
+      def write(text = "")
         # sssshhhhh!!
       end
     end
@@ -16,6 +18,24 @@ module ActiveRecord
         create_table("horses") do |t|
           t.column :content, :text
           t.column :remind_at, :datetime
+          t.column :place_id, :integer
+        end
+      end
+    end
+
+    class InvertibleChangeTableMigration < SilentMigration
+      def change
+        change_table("horses") do |t|
+          t.column :name, :string
+          t.remove :remind_at, type: :datetime
+        end
+      end
+    end
+
+    class InvertibleTransactionMigration < InvertibleMigration
+      def change
+        transaction do
+          super
         end
       end
     end
@@ -67,6 +87,7 @@ module ActiveRecord
           t.column :name, :string
           t.column :color, :string
           t.index [:name, :color]
+          t.index [:color]
         end
       end
     end
@@ -75,6 +96,7 @@ module ActiveRecord
       def change
         change_table("horses") do |t|
           t.remove_index [:name, :color]
+          t.remove_index [:color], if_exists: true
         end
       end
     end
@@ -93,6 +115,32 @@ module ActiveRecord
       end
     end
 
+    class ChangeColumnComment1 < SilentMigration
+      def change
+        create_table("horses") do |t|
+          t.column :name, :string, comment: "Sekitoba"
+        end
+      end
+    end
+
+    class ChangeColumnComment2 < SilentMigration
+      def change
+        change_column_comment :horses, :name, from: "Sekitoba", to: "Diomed"
+      end
+    end
+
+    class ChangeTableComment1 < SilentMigration
+      def change
+        create_table("horses", comment: "Sekitoba")
+      end
+    end
+
+    class ChangeTableComment2 < SilentMigration
+      def change
+        change_table_comment :horses, from: "Sekitoba", to: "Diomed"
+      end
+    end
+
     class DisableExtension1 < SilentMigration
       def change
         enable_extension "hstore"
@@ -151,6 +199,12 @@ module ActiveRecord
       end
     end
 
+    class RevertNonNamedExpressionIndexMigration < SilentMigration
+      def change
+        add_index :horses, "remind_at, place_id"
+      end
+    end
+
     class RevertCustomForeignKeyTable < SilentMigration
       def change
         change_table(:horses) do |t|
@@ -159,16 +213,23 @@ module ActiveRecord
       end
     end
 
+    class UpOnlyMigration < SilentMigration
+      def change
+        add_column :horses, :oldie, :integer, default: 0
+        up_only { execute "update horses set oldie = 1" }
+      end
+    end
+
+    self.use_transactional_tests = false
+
     setup do
       @verbose_was, ActiveRecord::Migration.verbose = ActiveRecord::Migration.verbose, false
     end
 
     teardown do
       %w[horses new_horses].each do |table|
-        ActiveSupport::Deprecation.silence do
-          if ActiveRecord::Base.connection.table_exists?(table)
-            ActiveRecord::Base.connection.drop_table(table)
-          end
+        if ActiveRecord::Base.connection.table_exists?(table)
+          ActiveRecord::Base.connection.drop_table(table)
         end
       end
       ActiveRecord::Migration.verbose = @verbose_was
@@ -199,14 +260,14 @@ module ActiveRecord
     def test_migrate_up
       migration = InvertibleMigration.new
       migration.migrate(:up)
-      ActiveSupport::Deprecation.silence { assert migration.connection.table_exists?("horses"), "horses should exist" }
+      assert migration.connection.table_exists?("horses"), "horses should exist"
     end
 
     def test_migrate_down
       migration = InvertibleMigration.new
       migration.migrate :up
       migration.migrate :down
-      ActiveSupport::Deprecation.silence { assert !migration.connection.table_exists?("horses") }
+      assert_not migration.connection.table_exists?("horses")
     end
 
     def test_migrate_revert
@@ -214,36 +275,39 @@ module ActiveRecord
       revert = InvertibleRevertMigration.new
       migration.migrate :up
       revert.migrate :up
-      ActiveSupport::Deprecation.silence { assert !migration.connection.table_exists?("horses") }
+      assert_not migration.connection.table_exists?("horses")
       revert.migrate :down
-      ActiveSupport::Deprecation.silence { assert migration.connection.table_exists?("horses") }
+      assert migration.connection.table_exists?("horses")
+      migration.migrate :down
+      assert_not migration.connection.table_exists?("horses")
+    end
+
+    def test_migrate_revert_change_table
+      InvertibleMigration.new.migrate :up
+      migration = InvertibleChangeTableMigration.new
+      migration.migrate :up
+      assert_not migration.connection.column_exists?(:horses, :remind_at)
       migration.migrate :down
-      ActiveSupport::Deprecation.silence { assert !migration.connection.table_exists?("horses") }
+      assert migration.connection.column_exists?(:horses, :remind_at)
     end
 
     def test_migrate_revert_by_part
       InvertibleMigration.new.migrate :up
       received = []
       migration = InvertibleByPartsMigration.new
-      migration.test = ->(dir){
-        ActiveSupport::Deprecation.silence do
-          assert migration.connection.table_exists?("horses")
-          assert migration.connection.table_exists?("new_horses")
-        end
+      migration.test = ->(dir) {
+        assert migration.connection.table_exists?("horses")
+        assert migration.connection.table_exists?("new_horses")
         received << dir
       }
       migration.migrate :up
       assert_equal [:both, :up], received
-      ActiveSupport::Deprecation.silence do
-        assert !migration.connection.table_exists?("horses")
-        assert migration.connection.table_exists?("new_horses")
-      end
+      assert_not migration.connection.table_exists?("horses")
+      assert migration.connection.table_exists?("new_horses")
       migration.migrate :down
       assert_equal [:both, :up, :both, :down], received
-      ActiveSupport::Deprecation.silence do
-        assert migration.connection.table_exists?("horses")
-        assert !migration.connection.table_exists?("new_horses")
-      end
+      assert migration.connection.table_exists?("horses")
+      assert_not migration.connection.table_exists?("new_horses")
     end
 
     def test_migrate_revert_whole_migration
@@ -252,25 +316,34 @@ module ActiveRecord
         revert = RevertWholeMigration.new(klass)
         migration.migrate :up
         revert.migrate :up
-        ActiveSupport::Deprecation.silence { assert !migration.connection.table_exists?("horses") }
+        assert_not migration.connection.table_exists?("horses")
         revert.migrate :down
-        ActiveSupport::Deprecation.silence { assert migration.connection.table_exists?("horses") }
+        assert migration.connection.table_exists?("horses")
         migration.migrate :down
-        ActiveSupport::Deprecation.silence { assert !migration.connection.table_exists?("horses") }
+        assert_not migration.connection.table_exists?("horses")
       end
     end
 
     def test_migrate_nested_revert_whole_migration
       revert = NestedRevertWholeMigration.new(InvertibleRevertMigration)
       revert.migrate :down
-      ActiveSupport::Deprecation.silence { assert revert.connection.table_exists?("horses") }
+      assert revert.connection.table_exists?("horses")
       revert.migrate :up
-      ActiveSupport::Deprecation.silence { assert !revert.connection.table_exists?("horses") }
+      assert_not revert.connection.table_exists?("horses")
+    end
+
+    def test_migrate_revert_transaction
+      migration = InvertibleTransactionMigration.new
+      migration.migrate :up
+      assert migration.connection.table_exists?("horses")
+      migration.migrate :down
+      assert_not migration.connection.table_exists?("horses")
     end
 
     def test_migrate_revert_change_column_default
       migration1 = ChangeColumnDefault1.new
       migration1.migrate(:up)
+      Horse.reset_column_information
       assert_equal "Sekitoba", Horse.new.name
 
       migration2 = ChangeColumnDefault2.new
@@ -283,29 +356,65 @@ module ActiveRecord
       assert_equal "Sekitoba", Horse.new.name
     end
 
+    if ActiveRecord::Base.connection.supports_comments?
+      def test_migrate_revert_change_column_comment
+        migration1 = ChangeColumnComment1.new
+        migration1.migrate(:up)
+        Horse.reset_column_information
+        assert_equal "Sekitoba", Horse.columns_hash["name"].comment
+
+        migration2 = ChangeColumnComment2.new
+        migration2.migrate(:up)
+        Horse.reset_column_information
+        assert_equal "Diomed", Horse.columns_hash["name"].comment
+
+        migration2.migrate(:down)
+        Horse.reset_column_information
+        assert_equal "Sekitoba", Horse.columns_hash["name"].comment
+      end
+
+      def test_migrate_revert_change_table_comment
+        connection = ActiveRecord::Base.connection
+        migration1 = ChangeTableComment1.new
+        migration1.migrate(:up)
+        assert_equal "Sekitoba", connection.table_comment("horses")
+
+        migration2 = ChangeTableComment2.new
+        migration2.migrate(:up)
+        assert_equal "Diomed", connection.table_comment("horses")
+
+        migration2.migrate(:down)
+        assert_equal "Sekitoba", connection.table_comment("horses")
+      end
+    end
+
     if current_adapter?(:PostgreSQLAdapter)
       def test_migrate_enable_and_disable_extension
         migration1 = InvertibleMigration.new
         migration2 = DisableExtension1.new
         migration3 = DisableExtension2.new
 
+        assert_equal true, Horse.connection.extension_available?("hstore")
+
         migration1.migrate(:up)
         migration2.migrate(:up)
-        assert_equal true, Horse.connection.extension_enabled?('hstore')
+        assert_equal true, Horse.connection.extension_enabled?("hstore")
 
         migration3.migrate(:up)
-        assert_equal false, Horse.connection.extension_enabled?('hstore')
+        assert_equal false, Horse.connection.extension_enabled?("hstore")
 
         migration3.migrate(:down)
-        assert_equal true, Horse.connection.extension_enabled?('hstore')
+        assert_equal true, Horse.connection.extension_enabled?("hstore")
 
         migration2.migrate(:down)
-        assert_equal false, Horse.connection.extension_enabled?('hstore')
+        assert_equal false, Horse.connection.extension_enabled?("hstore")
+      ensure
+        enable_extension!("hstore", ActiveRecord::Base.connection)
       end
     end
 
     def test_revert_order
-      block = Proc.new{|t| t.string :name }
+      block = Proc.new { |t| t.string :name }
       recorder = ActiveRecord::Migration::CommandRecorder.new(ActiveRecord::Base.connection)
       recorder.instance_eval do
         create_table("apples", &block)
@@ -330,35 +439,35 @@ module ActiveRecord
 
     def test_legacy_up
       LegacyMigration.migrate :up
-      ActiveSupport::Deprecation.silence { assert ActiveRecord::Base.connection.table_exists?("horses"), "horses should exist" }
+      assert ActiveRecord::Base.connection.table_exists?("horses"), "horses should exist"
     end
 
     def test_legacy_down
       LegacyMigration.migrate :up
       LegacyMigration.migrate :down
-      ActiveSupport::Deprecation.silence { assert !ActiveRecord::Base.connection.table_exists?("horses"), "horses should not exist" }
+      assert_not ActiveRecord::Base.connection.table_exists?("horses"), "horses should not exist"
     end
 
     def test_up
       LegacyMigration.up
-      ActiveSupport::Deprecation.silence { assert ActiveRecord::Base.connection.table_exists?("horses"), "horses should exist" }
+      assert ActiveRecord::Base.connection.table_exists?("horses"), "horses should exist"
     end
 
     def test_down
       LegacyMigration.up
       LegacyMigration.down
-      ActiveSupport::Deprecation.silence { assert !ActiveRecord::Base.connection.table_exists?("horses"), "horses should not exist" }
+      assert_not ActiveRecord::Base.connection.table_exists?("horses"), "horses should not exist"
     end
 
     def test_migrate_down_with_table_name_prefix
-      ActiveRecord::Base.table_name_prefix = 'p_'
-      ActiveRecord::Base.table_name_suffix = '_s'
+      ActiveRecord::Base.table_name_prefix = "p_"
+      ActiveRecord::Base.table_name_suffix = "_s"
       migration = InvertibleMigration.new
       migration.migrate(:up)
       assert_nothing_raised { migration.migrate(:down) }
-      ActiveSupport::Deprecation.silence { assert !ActiveRecord::Base.connection.table_exists?("p_horses_s"), "p_horses_s should not exist" }
+      assert_not ActiveRecord::Base.connection.table_exists?("p_horses_s"), "p_horses_s should not exist"
     ensure
-      ActiveRecord::Base.table_name_prefix = ActiveRecord::Base.table_name_suffix = ''
+      ActiveRecord::Base.table_name_prefix = ActiveRecord::Base.table_name_suffix = ""
     end
 
     def test_migrations_can_handle_foreign_keys_to_specific_tables
@@ -369,7 +478,7 @@ module ActiveRecord
     end
 
     # MySQL 5.7 and Oracle do not allow to create duplicate indexes on the same columns
-    unless current_adapter?(:Mysql2Adapter, :OracleAdapter)
+    unless current_adapter?(:Mysql2Adapter, :OracleAdapter, :IBM_DBAdapter)
       def test_migrate_revert_add_index_with_name
         RevertNamedIndexMigration1.new.migrate(:up)
         RevertNamedIndexMigration2.new.migrate(:up)
@@ -378,10 +487,41 @@ module ActiveRecord
         connection = ActiveRecord::Base.connection
         assert connection.index_exists?(:horses, :content),
                "index on content should exist"
-        assert !connection.index_exists?(:horses, :content, name: "horses_index_named"),
+        assert_not connection.index_exists?(:horses, :content, name: "horses_index_named"),
               "horses_index_named index should not exist"
       end
     end
 
+    def test_migrate_revert_add_index_without_name_on_expression
+      InvertibleMigration.new.migrate(:up)
+      RevertNonNamedExpressionIndexMigration.new.migrate(:up)
+
+      connection = ActiveRecord::Base.connection
+      assert connection.index_exists?(:horses, [:remind_at, :place_id]),
+             "index on remind_at and place_id should exist"
+
+      RevertNonNamedExpressionIndexMigration.new.migrate(:down)
+
+      assert_not connection.index_exists?(:horses, [:remind_at, :place_id]),
+             "index on remind_at and place_id should not exist"
+    end
+
+    def test_up_only
+      InvertibleMigration.new.migrate(:up)
+      horse1 = Horse.create
+      # populates existing horses with oldie = 1 but new ones have default 0
+      UpOnlyMigration.new.migrate(:up)
+      Horse.reset_column_information
+      horse1.reload
+      horse2 = Horse.create
+
+      assert 1, horse1.oldie # created before migration
+      assert 0, horse2.oldie # created after migration
+
+      UpOnlyMigration.new.migrate(:down) # should be no error
+      connection = ActiveRecord::Base.connection
+      assert_not connection.column_exists?(:horses, :oldie)
+      Horse.reset_column_information
+    end
   end
 end