ibm_db 5.6.1 → 5.7.0

data/test/active_record/connection_adapters/fake_legacy_adapter.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionHandling
+    def fake_legacy_connection(config)
+      ConnectionAdapters::FakeLegacyAdapter.new nil, logger
+    end
+  end
+
+  module ConnectionAdapters
+    class FakeLegacyAdapter < AbstractAdapter
+      def active?
+        true
+      end
+    end
+  end
+end

data/test/active_record/connection_adapters/fake_misleading_legacy_adapter.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    class FakeMisleadingLegacyAdapter < AbstractAdapter
+    end
+  end
+end

data/test/activejob/destroy_association_async_job_test.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+class UndefinedConstantAsync < ActiveRecord::Base
+  self.destroy_association_async_job = "UndefinedConstantJob"
+end
+
+autoload :UnloadableBaseJob, "activejob/unloadable_base_job"
+class UnloadableBaseAsync < ActiveRecord::Base
+  self.destroy_association_async_job = "UnloadableBaseJob"
+end
+
+class UnusedBelongsToAsync < ActiveRecord::Base
+  self.destroy_association_async_job = nil
+end
+
+class UnusedHasOneAsync < ActiveRecord::Base
+  self.destroy_association_async_job = nil
+end
+
+class UnusedHasManyAsync < ActiveRecord::Base
+  self.destroy_association_async_job = nil
+end
+
+
+class DestroyAssociationAsyncJobTest < ActiveRecord::TestCase
+  test "destroy_association_async_job requires valid job class" do
+    error = assert_raises NameError do
+      UndefinedConstantAsync.belongs_to :essay_destroy_async, dependent: :destroy_async
+    end
+    assert_match %r/destroy_association_async_job: uninitialized constant UndefinedConstantJob/, error.message
+  end
+
+  test "destroy_association_async_job error shows a missing parent job class, as if ActiveJob were missing" do
+    error = assert_raises NameError do
+      UnloadableBaseAsync.belongs_to :essay_destroy_async, dependent: :destroy_async
+    end
+    assert_match %r/destroy_association_async_job: uninitialized constant PretendActiveJobIsNotPresent/, error.message
+  end
+
+  test "belongs_to dependent destroy_async requires destroy_association_async_job" do
+    error = assert_raises ActiveRecord::ConfigurationError do
+      UnusedBelongsToAsync.belongs_to :essay_destroy_async, dependent: :destroy_async
+    end
+    assert_match %r/destroy_association_async_job/, error.message
+  end
+
+  test "has_one dependent destroy_async requires destroy_association_async_job" do
+    error = assert_raises ActiveRecord::ConfigurationError do
+      UnusedHasOneAsync.has_one :essay_destroy_async, dependent: :destroy_async
+    end
+    assert_match %r/destroy_association_async_job/, error.message
+  end
+
+  test "has_many dependent destroy_async requires destroy_association_async_job" do
+    error = assert_raises ActiveRecord::ConfigurationError do
+      UnusedHasManyAsync.has_many :essay_destroy_asyncs, dependent: :destroy_async
+    end
+    assert_match %r/destroy_association_async_job/, error.message
+  end
+end

data/test/activejob/destroy_association_async_test.rb

@@ -6,6 +6,7 @@ require "models/book_destroy_async"
 require "models/essay_destroy_async"
 require "models/tag"
 require "models/tagging"
+require "models/author"
 require "models/essay"
 require "models/category"
 require "models/post"
@@ -18,10 +19,16 @@ require "models/dl_keyed_has_one"
 require "models/dl_keyed_join"
 require "models/dl_keyed_has_many"
 require "models/dl_keyed_has_many_through"
+require "models/sharded/blog_post_destroy_async"
+require "models/sharded/comment_destroy_async"
+require "models/sharded/tag"
+require "models/sharded/blog_post"
+require "models/sharded/blog_post_tag"
+require "models/sharded/blog"
+require "models/cpk/book_destroy_async"
+require "models/cpk/chapter_destroy_async"
 
 class DestroyAssociationAsyncTest < ActiveRecord::TestCase
-  self.use_transactional_tests = false
-
   include ActiveJob::TestHelper
 
   test "destroying a record destroys the has_many :through records using a job" do
@@ -31,7 +38,9 @@ class DestroyAssociationAsyncTest < ActiveRecord::TestCase
     book.tags << [tag, tag2]
     book.save!
 
-    book.destroy
+    assert_enqueued_jobs 1, only: ActiveRecord::DestroyAssociationAsyncJob do
+      book.destroy
+    end
 
     assert_difference -> { Tag.count }, -2 do
       perform_enqueued_jobs only: ActiveRecord::DestroyAssociationAsyncJob
@@ -41,6 +50,39 @@ class DestroyAssociationAsyncTest < ActiveRecord::TestCase
     BookDestroyAsync.delete_all
   end
 
+  test "destroying a record destroys has_many :through associated by composite primary key using a job" do
+    blog = Sharded::Blog.create!
+    blog_post = Sharded::BlogPostDestroyAsync.create!(blog_id: blog.id)
+
+    tag1 = Sharded::Tag.create!(name: "Short Read", blog_id: blog.id)
+    tag2 = Sharded::Tag.create!(name: "Science", blog_id: blog.id)
+
+    blog_post.tags << [tag1, tag2]
+
+    blog_post.save!
+
+    assert_enqueued_jobs 1, only: ActiveRecord::DestroyAssociationAsyncJob do
+      blog_post.destroy
+    end
+
+    sql = capture_sql do
+      assert_difference -> { Sharded::Tag.count }, -2 do
+        perform_enqueued_jobs only: ActiveRecord::DestroyAssociationAsyncJob
+      end
+    end
+
+    delete_sqls = sql.select { |sql| sql.start_with?("DELETE") }
+    assert_equal 2, delete_sqls.count
+
+    delete_sqls.each do |sql|
+      assert_match(/#{Regexp.escape(quote_table_name("sharded_tags.blog_id"))} =/, sql)
+    end
+  ensure
+    Sharded::Tag.delete_all
+    Sharded::BlogPostDestroyAsync.delete_all
+    Sharded::Blog.delete_all
+  end
+
   test "destroying a scoped has_many through only deletes within the scope deleted" do
     tag = Tag.create!(name: "Der be treasure")
     tag2 = Tag.create!(name: "Der be rum")
@@ -74,16 +116,43 @@ class DestroyAssociationAsyncTest < ActiveRecord::TestCase
     parent.destroy
 
     assert_difference -> { DlKeyedJoin.count }, -2 do
-     assert_difference -> { DlKeyedHasManyThrough.count }, -2 do
-      perform_enqueued_jobs only: ActiveRecord::DestroyAssociationAsyncJob
+      assert_difference -> { DlKeyedHasManyThrough.count }, -2 do
+        perform_enqueued_jobs only: ActiveRecord::DestroyAssociationAsyncJob
+      end
     end
-   end
   ensure
     DlKeyedHasManyThrough.delete_all
     DestroyAsyncParent.delete_all
     DlKeyedJoin.delete_all
   end
 
+  test "enqueues multiple jobs if count of dependent records to destroy is greater than batch size" do
+    ActiveRecord::Base.destroy_association_async_batch_size = 1
+
+    tag = Tag.create!(name: "Der be treasure")
+    tag2 = Tag.create!(name: "Der be rum")
+    book = BookDestroyAsync.create!
+    book.tags << [tag, tag2]
+    book.save!
+
+    job_1_args = ->(job_args) { job_args.first[:association_ids] == [tag.id] }
+    job_2_args = ->(job_args) { job_args.first[:association_ids] == [tag2.id] }
+
+    assert_enqueued_with(job: ActiveRecord::DestroyAssociationAsyncJob, args: job_1_args) do
+      assert_enqueued_with(job: ActiveRecord::DestroyAssociationAsyncJob, args: job_2_args) do
+        book.destroy
+      end
+    end
+
+    assert_difference -> { Tag.count }, -2 do
+      perform_enqueued_jobs only: ActiveRecord::DestroyAssociationAsyncJob
+    end
+  ensure
+    Tag.delete_all
+    BookDestroyAsync.delete_all
+    ActiveRecord::Base.destroy_association_async_batch_size = nil
+  end
+
   test "belongs to" do
     essay = EssayDestroyAsync.create!(name: "Der be treasure")
     book = BookDestroyAsync.create!(name: "Arr, matey!")
@@ -99,6 +168,33 @@ class DestroyAssociationAsyncTest < ActiveRecord::TestCase
     BookDestroyAsync.delete_all
   end
 
+  test "belongs to associated by composite primary key" do
+    blog = Sharded::Blog.create!
+    blog_post = Sharded::BlogPostDestroyAsync.create!(blog_id: blog.id)
+    comment = Sharded::CommentDestroyAsync.create!(body: "Great post! :clap:")
+
+    comment.blog_post = blog_post
+    comment.save!
+
+    assert_enqueued_jobs 1, only: ActiveRecord::DestroyAssociationAsyncJob do
+      comment.destroy
+    end
+
+    sql = capture_sql do
+      assert_difference -> { Sharded::BlogPostDestroyAsync.count }, -1 do
+        perform_enqueued_jobs only: ActiveRecord::DestroyAssociationAsyncJob
+      end
+    end
+
+    delete_sqls = sql.select { |sql| sql.start_with?("DELETE") }
+    assert_equal 1, delete_sqls.count
+    assert_match(/#{Regexp.escape(quote_table_name("sharded_blog_posts.blog_id"))} =/, delete_sqls.first)
+  ensure
+    Sharded::BlogPostDestroyAsync.delete_all
+    Sharded::CommentDestroyAsync.delete_all
+    Sharded::Blog.delete_all
+  end
+
   test "enqueues belongs_to to be deleted with custom primary key" do
     belongs = DlKeyedBelongsTo.create!
     parent = DestroyAsyncParent.create!
@@ -114,6 +210,20 @@ class DestroyAssociationAsyncTest < ActiveRecord::TestCase
     DestroyAsyncParent.delete_all
   end
 
+  test "polymorphic belongs_to" do
+    writer = Author.create(name: "David")
+    essay = EssayDestroyAsync.create!(name: "Der be treasure", writer: writer)
+
+    essay.destroy
+
+    assert_difference -> { Author.count }, -1 do
+      perform_enqueued_jobs only: ActiveRecord::DestroyAssociationAsyncJob
+    end
+  ensure
+    EssayDestroyAsync.delete_all
+    Author.delete_all
+  end
+
   test "has_one" do
     content = Content.create(title: "hello")
     book = BookDestroyAsync.create!(name: "Arr, matey!")
@@ -162,7 +272,7 @@ class DestroyAssociationAsyncTest < ActiveRecord::TestCase
     BookDestroyAsync.delete_all
   end
 
-  test "has_many with sti parent class destroys all children class records" do
+  test "has_many with STI parent class destroys all children class records" do
     book = BookDestroyAsync.create!
     LongEssayDestroyAsync.create!(book: book)
     ShortEssayDestroyAsync.create!(book: book)
@@ -189,6 +299,32 @@ class DestroyAssociationAsyncTest < ActiveRecord::TestCase
     DestroyAsyncParent.delete_all
   end
 
+  test "has_many associated with composite primary key" do
+    book = Cpk::BookDestroyAsync.create!(id: [1, 1])
+    _chapter1 = book.chapters.create!(id: [1, 1], title: "Chapter 1")
+    _chapter2 = book.chapters.create!(id: [1, 2], title: "Chapter 2")
+
+    assert_enqueued_jobs 1, only: ActiveRecord::DestroyAssociationAsyncJob do
+      book.destroy
+    end
+
+    sql = capture_sql do
+      assert_difference -> { Cpk::ChapterDestroyAsync.count }, -2 do
+        perform_enqueued_jobs only: ActiveRecord::DestroyAssociationAsyncJob
+      end
+    end
+
+    delete_sqls = sql.select { |sql| sql.start_with?("DELETE") }
+    assert_equal 2, delete_sqls.count
+
+    delete_sqls.each do |sql|
+      assert_match(/#{Regexp.escape(quote_table_name("cpk_chapters.author_id"))} =/, sql)
+    end
+  ensure
+    Cpk::ChapterDestroyAsync.delete_all
+    Cpk::BookDestroyAsync.delete_all
+  end
+
   test "not enqueue the job if transaction is not committed" do
     dl_keyed_has_many = DlKeyedHasMany.new
     parent = DestroyAsyncParent.create!
@@ -272,7 +408,7 @@ class DestroyAssociationAsyncTest < ActiveRecord::TestCase
 
     belongs.destroy
     perform_enqueued_jobs only: ActiveRecord::DestroyAssociationAsyncJob
-    assert parent.reload.deleted?
+    assert_predicate parent.reload, :deleted?
   ensure
     DlKeyedBelongsToSoftDelete.delete_all
     DestroyAsyncParentSoftDelete.delete_all
@@ -298,8 +434,8 @@ class DestroyAssociationAsyncTest < ActiveRecord::TestCase
       raise ActiveRecord::Rollback
     end
     assert_no_enqueued_jobs only: ActiveRecord::DestroyAssociationAsyncJob
+  ensure
+    Tag.delete_all
+    BookDestroyAsync.delete_all
   end
-ensure
-  Tag.delete_all
-  BookDestroyAsync.delete_all
 end

data/test/activejob/job_runtime_test.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "activejob/helper"
+require "active_record/railties/job_runtime"
+
+class JobRuntimeTest < ActiveSupport::TestCase
+  class TestJob < ActiveJob::Base
+    include ActiveRecord::Railties::JobRuntime
+
+    def perform(*)
+      ActiveRecord::RuntimeRegistry.sql_runtime += 42.0
+    end
+  end
+
+  test "job notification payload includes db_runtime" do
+    ActiveRecord::RuntimeRegistry.sql_runtime = 0.0
+
+    assert_equal 42, notification_payload[:db_runtime]
+  end
+
+  test "db_runtime tracks database runtime for job only" do
+    ActiveRecord::RuntimeRegistry.sql_runtime = 100.0
+
+    assert_equal 42.0, notification_payload[:db_runtime]
+    assert_equal 142.0, ActiveRecord::RuntimeRegistry.sql_runtime
+  end
+
+  private
+    def notification_payload
+      payload = nil
+      subscriber = ActiveSupport::Notifications.subscribe("perform.active_job") do |*, _payload|
+        payload = _payload
+      end
+
+      TestJob.perform_now
+
+      ActiveSupport::Notifications.unsubscribe(subscriber)
+
+      payload
+    end
+end

data/test/activejob/unloadable_base_job.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+class UnloadableBaseJob < PretendActiveJobIsNotPresent; end

data/test/cases/active_record_schema_test.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+
+class ActiveRecordSchemaTest < ActiveRecord::TestCase
+  self.use_transactional_tests = false
+
+  setup do
+    @original_verbose = ActiveRecord::Migration.verbose
+    ActiveRecord::Migration.verbose = false
+    @connection = ActiveRecord::Base.lease_connection
+    @pool = ActiveRecord::Base.connection_pool
+    @schema_migration = @pool.schema_migration
+    @schema_migration.delete_all_versions
+  end
+
+  teardown do
+    @connection.drop_table :fruits rescue nil
+    @connection.drop_table :has_timestamps rescue nil
+    @connection.drop_table :multiple_indexes rescue nil
+    @schema_migration.delete_all_versions
+    ActiveRecord::Migration.verbose = @original_verbose
+  end
+
+  def test_has_primary_key
+    old_primary_key_prefix_type = ActiveRecord::Base.primary_key_prefix_type
+    ActiveRecord::Base.primary_key_prefix_type = :table_name_with_underscore
+    assert_equal "version", @schema_migration.primary_key
+
+    assert_difference "@schema_migration.count", 1 do
+      @schema_migration.create_version(12)
+    end
+  ensure
+    ActiveRecord::Base.primary_key_prefix_type = old_primary_key_prefix_type
+  end
+
+  def test_schema_without_version_is_the_current_version_schema
+    schema_class = ActiveRecord::Schema
+    assert schema_class < ActiveRecord::Migration[ActiveRecord::Migration.current_version]
+    assert_not schema_class < ActiveRecord::Migration[7.0]
+    assert schema_class < ActiveRecord::Schema::Definition
+  end
+
+  def test_schema_version_accessor
+    schema_class = ActiveRecord::Schema[6.1]
+    assert schema_class < ActiveRecord::Migration[6.1]
+    assert schema_class < ActiveRecord::Schema::Definition
+  end
+
+  def test_schema_define
+    ActiveRecord::Schema.define(version: 7) do
+      create_table :fruits do |t|
+        t.column :color, :string
+        t.column :fruit_size, :string  # NOTE: "size" is reserved in Oracle
+        t.column :texture, :string
+        t.column :flavor, :string
+      end
+    end
+
+    assert_nothing_raised { @connection.select_all "SELECT * FROM fruits" }
+    assert_nothing_raised { @connection.select_all "SELECT * FROM schema_migrations" }
+    assert_equal 7, @connection.schema_version
+  end
+
+  def test_schema_define_with_table_name_prefix
+    old_table_name_prefix = ActiveRecord::Base.table_name_prefix
+    ActiveRecord::Base.table_name_prefix = "nep_"
+    ActiveRecord::Schema.define(version: 7) do
+      create_table :fruits do |t|
+        t.column :color, :string
+        t.column :fruit_size, :string  # NOTE: "size" is reserved in Oracle
+        t.column :texture, :string
+        t.column :flavor, :string
+      end
+    end
+    assert_equal 7, @pool.migration_context.current_version
+  ensure
+    ActiveRecord::Base.table_name_prefix = old_table_name_prefix
+    @connection.drop_table :nep_fruits
+    @connection.drop_table :nep_schema_migrations
+    @schema_migration.create_table
+  end
+
+  def test_schema_raises_an_error_for_invalid_column_type
+    assert_raise NoMethodError do
+      ActiveRecord::Schema.define(version: 8) do
+        create_table :vegetables do |t|
+          t.unknown :color
+        end
+      end
+    end
+  end
+
+  def test_schema_subclass
+    Class.new(ActiveRecord::Schema).define(version: 9) do
+      create_table :fruits
+    end
+    assert_nothing_raised { @connection.select_all "SELECT * FROM fruits" }
+  end
+
+  def test_normalize_version
+    assert_equal "118", @schema_migration.normalize_migration_number("0000118")
+    assert_equal "002", @schema_migration.normalize_migration_number("2")
+    assert_equal "017", @schema_migration.normalize_migration_number("0017")
+    assert_equal "20131219224947", @schema_migration.normalize_migration_number("20131219224947")
+  end
+
+  def test_schema_load_with_multiple_indexes_for_column_of_different_names
+    ibm_db_adapter = current_adapter?(:IBM_DBAdapter)
+
+    ActiveRecord::Schema.define do
+      create_table :multiple_indexes do |t|
+        t.string "foo"
+        t.index ["foo"], name: "multiple_indexes_foo_1"
+        t.index ["foo"], name: "multiple_indexes_foo_2" unless ibm_db_adapter
+      end
+    end
+
+    indexes = @connection.indexes("multiple_indexes")
+
+    if ibm_db_adapter
+      assert_equal 1, indexes.length
+      assert_equal ["multiple_indexes_foo_1"], indexes.collect(&:name).sort
+    else
+      assert_equal 2, indexes.length
+      assert_equal ["multiple_indexes_foo_1", "multiple_indexes_foo_2"], indexes.collect(&:name).sort
+    end
+  end
+
+  if current_adapter?(:PostgreSQLAdapter)
+    def test_timestamps_with_and_without_zones
+      ActiveRecord::Schema.define do
+        create_table :has_timestamps do |t|
+          t.datetime "default_format"
+          t.datetime "without_time_zone"
+          t.timestamp "also_without_time_zone"
+          t.timestamptz "with_time_zone"
+        end
+      end
+
+      assert @connection.column_exists?(:has_timestamps, :default_format, :datetime)
+      assert @connection.column_exists?(:has_timestamps, :without_time_zone, :datetime)
+      assert @connection.column_exists?(:has_timestamps, :also_without_time_zone, :datetime)
+      assert @connection.column_exists?(:has_timestamps, :with_time_zone, :timestamptz)
+    end
+  end
+
+  def test_timestamps_with_implicit_default_on_create_table
+    ActiveRecord::Schema.define do
+      create_table :has_timestamps do |t|
+        t.timestamps
+      end
+    end
+
+    assert @connection.column_exists?(:has_timestamps, :created_at, precision: 6, null: false)
+    assert @connection.column_exists?(:has_timestamps, :updated_at, precision: 6, null: false)
+  end
+
+  def test_timestamps_with_implicit_default_on_change_table
+    ActiveRecord::Schema.define do
+      create_table :has_timestamps
+
+      change_table :has_timestamps do |t|
+        t.timestamps default: Time.now
+      end
+    end
+
+    assert @connection.column_exists?(:has_timestamps, :created_at, precision: 6, null: false)
+    assert @connection.column_exists?(:has_timestamps, :updated_at, precision: 6, null: false)
+  end
+
+  if ActiveRecord::Base.lease_connection.supports_bulk_alter?
+    def test_timestamps_with_implicit_default_on_change_table_with_bulk
+      ActiveRecord::Schema.define do
+        create_table :has_timestamps
+
+        change_table :has_timestamps, bulk: true do |t|
+          t.timestamps default: Time.now
+        end
+      end
+
+      assert @connection.column_exists?(:has_timestamps, :created_at, precision: 6, null: false)
+      assert @connection.column_exists?(:has_timestamps, :updated_at, precision: 6, null: false)
+    end
+  end
+
+  def test_timestamps_with_implicit_default_on_add_timestamps
+    ActiveRecord::Schema.define do
+      create_table :has_timestamps
+      add_timestamps :has_timestamps, default: Time.now
+    end
+
+    assert @connection.column_exists?(:has_timestamps, :created_at, precision: 6, null: false)
+    assert @connection.column_exists?(:has_timestamps, :updated_at, precision: 6, null: false)
+  end
+end

data/test/cases/active_record_test.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "rack"
+
+class ActiveRecordTest < ActiveRecord::TestCase
+  self.use_transactional_tests = false
+
+  unless in_memory_db?
+    test ".disconnect_all! closes all connections" do
+      ActiveRecord::Base.lease_connection.connect!
+      assert_predicate ActiveRecord::Base, :connected?
+
+      ActiveRecord.disconnect_all!
+      assert_not_predicate ActiveRecord::Base, :connected?
+
+      ActiveRecord::Base.lease_connection.connect!
+      assert_predicate ActiveRecord::Base, :connected?
+    end
+  end
+end