ibm_db 5.6.1 → 5.7.0

data/test/cases/query_logs_test.rb

@@ -0,0 +1,293 @@
+# frozen_string_literal: true
+
+require "cases/helper"
+require "models/dashboard"
+
+class QueryLogsTest < ActiveRecord::TestCase
+  fixtures :dashboards
+
+  def setup
+    # ActiveSupport::ExecutionContext context is automatically reset in Rails app via an executor hooks set in railtie
+    # But not in Active Record's own test suite.
+    ActiveSupport::ExecutionContext.clear
+
+    # Enable the query tags logging
+    @original_transformers = ActiveRecord.query_transformers
+    @original_prepend = ActiveRecord::QueryLogs.prepend_comment
+    @original_tags = ActiveRecord::QueryLogs.tags
+    @original_taggings = ActiveRecord::QueryLogs.taggings
+    ActiveRecord.query_transformers += [ActiveRecord::QueryLogs]
+    ActiveRecord::QueryLogs.prepend_comment = false
+    ActiveRecord::QueryLogs.cache_query_log_tags = false
+    ActiveRecord::QueryLogs.cached_comment = nil
+    ActiveRecord::QueryLogs.taggings = {
+      application: -> { "active_record" }
+    }
+  end
+
+  def teardown
+    ActiveRecord.query_transformers = @original_transformers
+    ActiveRecord::QueryLogs.prepend_comment = @original_prepend
+    ActiveRecord::QueryLogs.tags = @original_tags
+    ActiveRecord::QueryLogs.taggings = @original_taggings
+    ActiveRecord::QueryLogs.prepend_comment = false
+    ActiveRecord::QueryLogs.cache_query_log_tags = false
+    ActiveRecord::QueryLogs.clear_cache
+    ActiveRecord::QueryLogs.tags_formatter = :legacy
+
+    # ActiveSupport::ExecutionContext context is automatically reset in Rails app via an executor hooks set in railtie
+    # But not in Active Record's own test suite.
+    ActiveSupport::ExecutionContext.clear
+  end
+
+  def test_escaping_good_comment
+    assert_equal "app:foo", ActiveRecord::QueryLogs.send(:escape_sql_comment, "app:foo")
+  end
+
+  def test_escaping_good_comment_with_custom_separator
+    ActiveRecord::QueryLogs.tags_formatter = :sqlcommenter
+
+    assert_equal "app='foo'", ActiveRecord::QueryLogs.send(:escape_sql_comment, "app='foo'")
+  end
+
+  def test_escaping_bad_comments
+    assert_equal "* /; DROP TABLE USERS;/ *", ActiveRecord::QueryLogs.send(:escape_sql_comment, "*/; DROP TABLE USERS;/*")
+    assert_equal "** //; DROP TABLE USERS;/ *", ActiveRecord::QueryLogs.send(:escape_sql_comment, "**//; DROP TABLE USERS;/*")
+    assert_equal "* * //; DROP TABLE USERS;// * *", ActiveRecord::QueryLogs.send(:escape_sql_comment, "* *//; DROP TABLE USERS;//* *")
+  end
+
+  def test_basic_commenting
+    ActiveRecord::QueryLogs.tags = [ :application ]
+
+    assert_queries_match(%r{select id from posts /\*application:active_record\*/$}) do
+      ActiveRecord::Base.lease_connection.execute "select id from posts"
+    end
+  end
+
+  def test_add_comments_to_beginning_of_query
+    ActiveRecord::QueryLogs.tags = [ :application ]
+    ActiveRecord::QueryLogs.prepend_comment = true
+
+    assert_queries_match(%r{/\*application:active_record\*/ select id from posts$}) do
+      ActiveRecord::Base.lease_connection.execute "select id from posts"
+    end
+  end
+
+  def test_exists_is_commented
+    ActiveRecord::QueryLogs.tags = [ :application ]
+    assert_queries_match(%r{/\*application:active_record\*/}) do
+      Dashboard.exists?
+    end
+  end
+
+  def test_delete_is_commented
+    ActiveRecord::QueryLogs.tags = [ :application ]
+    record = Dashboard.first
+
+    assert_queries_match(%r{/\*application:active_record\*/}) do
+      record.destroy
+    end
+  end
+
+  def test_update_is_commented
+    ActiveRecord::QueryLogs.tags = [ :application ]
+
+    assert_queries_match(%r{/\*application:active_record\*/}) do
+      dash = Dashboard.first
+      dash.name = "New name"
+      dash.save
+    end
+  end
+
+  def test_create_is_commented
+    ActiveRecord::QueryLogs.tags = [ :application ]
+
+    assert_queries_match(%r{/\*application:active_record\*/}) do
+      Dashboard.create(name: "Another dashboard")
+    end
+  end
+
+  def test_select_is_commented
+    ActiveRecord::QueryLogs.tags = [ :application ]
+
+    assert_queries_match(%r{/\*application:active_record\*/}) do
+      Dashboard.all.to_a
+    end
+  end
+
+  def test_retrieves_comment_from_cache_when_enabled_and_set
+    ActiveRecord::QueryLogs.cache_query_log_tags = true
+    i = 0
+    ActiveRecord::QueryLogs.tags = [ { query_counter: -> { i += 1 } } ]
+
+    assert_queries_match(select_one_with_comment("/*query_counter:1*/")) do
+      ActiveRecord::Base.lease_connection.execute "SELECT 1"
+    end
+
+    assert_queries_match(select_one_with_comment("/*query_counter:1*/")) do
+      ActiveRecord::Base.lease_connection.execute "SELECT 1"
+    end
+  end
+
+  def test_resets_cache_on_context_update
+    ActiveRecord::QueryLogs.cache_query_log_tags = true
+    ActiveSupport::ExecutionContext[:temporary] = "value"
+    ActiveRecord::QueryLogs.tags = [ temporary_tag: ->(context) { context[:temporary] } ]
+
+    assert_queries_match(select_one_with_comment("/*temporary_tag:value*/")) do
+      ActiveRecord::Base.lease_connection.execute "SELECT 1"
+    end
+
+    ActiveSupport::ExecutionContext[:temporary] = "new_value"
+
+    assert_queries_match(select_one_with_comment("/*temporary_tag:new_value*/")) do
+      ActiveRecord::Base.lease_connection.execute "SELECT 1"
+    end
+  end
+
+  def test_default_tag_behavior
+    ActiveRecord::QueryLogs.tags = [:application, :foo]
+    ActiveSupport::ExecutionContext.set(foo: "bar") do
+      assert_queries_match(%r{/\*application:active_record,foo:bar\*/}) do
+        Dashboard.first
+      end
+    end
+    assert_queries_match(%r{/\*application:active_record\*/}) do
+      Dashboard.first
+    end
+  end
+
+  def test_connection_is_passed_to_tagging_proc
+    connection = ActiveRecord::Base.lease_connection
+    ActiveRecord::QueryLogs.tags = [ same_connection: ->(context) { context[:connection] == connection } ]
+
+    assert_queries_match(select_one_with_comment("/*same_connection:true*/")) do
+      connection.execute "SELECT 1"
+    end
+  end
+
+  def test_connection_does_not_override_already_existing_connection_in_context
+    fake_connection = Object.new
+    ActiveSupport::ExecutionContext[:connection] = fake_connection
+    ActiveRecord::QueryLogs.tags = [ fake_connection: ->(context) { context[:connection] == fake_connection } ]
+
+    assert_queries_match(select_one_with_comment("/*fake_connection:true*/")) do
+      ActiveRecord::Base.lease_connection.execute "SELECT 1"
+    end
+  end
+
+  def test_empty_comments_are_not_added
+    ActiveRecord::QueryLogs.tags = [ empty: -> { nil } ]
+    assert_queries_match(%r{select id from posts$}) do
+      ActiveRecord::Base.lease_connection.execute "select id from posts"
+    end
+  end
+
+  def test_sql_commenter_format
+    ActiveRecord::QueryLogs.tags_formatter = :sqlcommenter
+    ActiveRecord::QueryLogs.tags = [:application]
+
+    assert_queries_match(%r{/\*application='active_record'\*/}) do
+      Dashboard.first
+    end
+  end
+
+  def test_custom_basic_tags
+    ActiveRecord::QueryLogs.tags = [ :application, { custom_string: "test content" } ]
+
+    assert_queries_match(%r{/\*application:active_record,custom_string:test content\*/}) do
+      Dashboard.first
+    end
+  end
+
+  def test_custom_proc_tags
+    ActiveRecord::QueryLogs.tags = [ :application, { custom_proc: -> { "test content" } } ]
+
+    assert_queries_match(%r{/\*application:active_record,custom_proc:test content\*/}) do
+      Dashboard.first
+    end
+  end
+
+  def test_multiple_custom_tags
+    ActiveRecord::QueryLogs.tags = [
+      :application,
+      { custom_proc: -> { "test content" }, another_proc: -> { "more test content" } },
+    ]
+
+    assert_queries_match(%r{/\*another_proc:more test content,application:active_record,custom_proc:test content\*/}) do
+      Dashboard.first
+    end
+  end
+
+  def test_sqlcommenter_format_value
+    ActiveRecord::QueryLogs.tags_formatter = :sqlcommenter
+
+    ActiveRecord::QueryLogs.tags = [
+      :application,
+      { tracestate: "congo=t61rcWkgMzE,rojo=00f067aa0ba902b7", custom_proc: -> { "Joe's Shack" } },
+    ]
+
+    assert_queries_match(%r{custom_proc='Joe%27s%20Shack',tracestate='congo%3Dt61rcWkgMzE%2Crojo%3D00f067aa0ba902b7'\*/}) do
+      Dashboard.first
+    end
+  end
+
+  def test_sqlcommenter_format_allows_string_keys
+    ActiveRecord::QueryLogs.tags_formatter = :sqlcommenter
+
+    ActiveRecord::QueryLogs.tags = [
+      :application,
+      {
+        "string" => "value",
+        tracestate: "congo=t61rcWkgMzE,rojo=00f067aa0ba902b7",
+        custom_proc: -> { "Joe's Shack" }
+      },
+    ]
+
+    assert_queries_match(%r{custom_proc='Joe%27s%20Shack',string='value',tracestate='congo%3Dt61rcWkgMzE%2Crojo%3D00f067aa0ba902b7'\*/}) do
+      Dashboard.first
+    end
+  end
+
+  def test_sqlcommenter_format_value_string_coercible
+    ActiveRecord::QueryLogs.tags_formatter = :sqlcommenter
+
+    ActiveRecord::QueryLogs.tags = [
+      :application,
+      { custom_proc: -> { 1234 } },
+    ]
+
+    assert_queries_match(%r{custom_proc='1234'\*/}) do
+      Dashboard.first
+    end
+  end
+
+  # PostgreSQL does validate the query encoding. Other adapters don't care.
+  # IBM_DB adapter also does not support encoding validation
+  unless current_adapter?(:PostgreSQLAdapter) || current_adapter?(:IBM_DBAdapter)
+    def test_invalid_encoding_query
+      ActiveRecord::QueryLogs.tags = [ :application ]
+      assert_nothing_raised do
+        ActiveRecord::Base.lease_connection.execute "select 1 as '\xFF'"
+      end
+    end
+  end
+
+  def test_custom_proc_context_tags
+    ActiveSupport::ExecutionContext[:foo] = "bar"
+    ActiveRecord::QueryLogs.tags = [ :application, { custom_context_proc: ->(context) { context[:foo] } } ]
+
+    assert_queries_match(%r{/\*application:active_record,custom_context_proc:bar\*/}) do
+      Dashboard.first
+    end
+  end
+
+  private
+    def select_one_with_comment(comment)
+      if current_adapter?(:IBM_DBAdapter)
+        "SELECT 1 FROM SYSIBM.SYSDUMMY1 #{comment}"
+      else
+        "SELECT 1 #{comment}"
+      end
+    end
+end

data/test/cases/quoting_test.rb

@@ -6,7 +6,13 @@ module ActiveRecord
   module ConnectionAdapters
     class QuotingTest < ActiveRecord::TestCase
       def setup
-        @quoter = Class.new { include Quoting }.new
+        @quoter = Class.new {
+          include Quoting
+
+          def default_timezone
+            ActiveRecord.default_timezone
+          end
+        }.new
       end
 
       def test_quoted_true
@@ -18,15 +24,22 @@ module ActiveRecord
       end
 
       def test_quote_column_name
-        assert_equal "foo", @quoter.quote_column_name("foo")
+        skip "IBM_DB adapter defines quote_column_name" if current_adapter?(:IBM_DBAdapter)
+        assert_raises NotImplementedError do
+          @quoter.quote_column_name("foo")
+        end
       end
 
       def test_quote_table_name
-        assert_equal "foo", @quoter.quote_table_name("foo")
+        skip "IBM_DB adapter defines quote_table_name" if current_adapter?(:IBM_DBAdapter)
+        assert_raises NotImplementedError do
+          @quoter.quote_table_name("foo")
+        end
       end
 
       def test_quote_table_name_calls_quote_column_name
-        @quoter.extend(Module.new {
+        skip "IBM_DB adapter overrides quote_table_name behavior" if current_adapter?(:IBM_DBAdapter)
+        @quoter.class.extend(Module.new {
           def quote_column_name(string)
             "lol"
           end
@@ -43,27 +56,20 @@ module ActiveRecord
 
       def test_quoted_date
         t = Date.today
-        assert_equal t.to_s(:db), @quoter.quoted_date(t)
+        assert_equal t.to_fs(:db), @quoter.quoted_date(t)
       end
 
       def test_quoted_timestamp_utc
         with_timezone_config default: :utc do
           t = Time.now.change(usec: 0)
-          assert_equal t.getutc.to_s(:db), @quoter.quoted_date(t)
+          assert_equal t.getutc.to_fs(:db), @quoter.quoted_date(t)
         end
       end
 
       def test_quoted_timestamp_local
         with_timezone_config default: :local do
           t = Time.now.change(usec: 0)
-          assert_equal t.getlocal.to_s(:db), @quoter.quoted_date(t)
-        end
-      end
-
-      def test_quoted_timestamp_crazy
-        with_timezone_config default: :asdfasdf do
-          t = Time.now.change(usec: 0)
-          assert_equal t.getlocal.to_s(:db), @quoter.quoted_date(t)
+          assert_equal t.getlocal.to_fs(:db), @quoter.quoted_date(t)
         end
       end
 
@@ -72,7 +78,7 @@ module ActiveRecord
           t = Time.now.change(usec: 0)
 
           expected = t.change(year: 2000, month: 1, day: 1)
-          expected = expected.getutc.to_s(:db).slice(11..-1)
+          expected = expected.getutc.to_fs(:db).slice(11..-1)
 
           assert_equal expected, @quoter.quoted_time(t)
         end
@@ -83,7 +89,7 @@ module ActiveRecord
           t = Time.now.change(usec: 0)
 
           expected = t.change(year: 2000, month: 1, day: 1)
-          expected = expected.getlocal.to_s(:db).sub("2000-01-01 ", "")
+          expected = expected.getlocal.to_fs(:db).sub("2000-01-01 ", "")
 
           assert_equal expected, @quoter.quoted_time(t)
         end
@@ -95,7 +101,7 @@ module ActiveRecord
             t = Time.new(2000, 7, 1, 0, 0, 0, "+04:30")
 
             expected = t.change(year: 2000, month: 1, day: 1)
-            expected = expected.getutc.to_s(:db).slice(11..-1)
+            expected = expected.getutc.to_fs(:db).slice(11..-1)
 
             assert_equal expected, @quoter.quoted_time(t)
           end
@@ -108,28 +114,17 @@ module ActiveRecord
             t = Time.new(2000, 7, 1, 0, 0, 0, "+04:30")
 
             expected = t.change(year: 2000, month: 1, day: 1)
-            expected = expected.getlocal.to_s(:db).slice(11..-1)
+            expected = expected.getlocal.to_fs(:db).slice(11..-1)
 
             assert_equal expected, @quoter.quoted_time(t)
           end
         end
       end
 
-      def test_quoted_time_crazy
-        with_timezone_config default: :asdfasdf do
-          t = Time.now.change(usec: 0)
-
-          expected = t.change(year: 2000, month: 1, day: 1)
-          expected = expected.getlocal.to_s(:db).sub("2000-01-01 ", "")
-
-          assert_equal expected, @quoter.quoted_time(t)
-        end
-      end
-
       def test_quoted_datetime_utc
         with_timezone_config default: :utc do
           t = Time.now.change(usec: 0).to_datetime
-          assert_equal t.getutc.to_s(:db), @quoter.quoted_date(t)
+          assert_equal t.getutc.to_fs(:db), @quoter.quoted_date(t)
         end
       end
 
@@ -138,7 +133,7 @@ module ActiveRecord
       def test_quoted_datetime_local
         with_timezone_config default: :local do
           t = Time.now.change(usec: 0).to_datetime
-          assert_equal t.to_s(:db), @quoter.quoted_date(t)
+          assert_equal t.to_fs(:db), @quoter.quoted_date(t)
         end
       end
 
@@ -185,10 +180,10 @@ module ActiveRecord
         assert_equal "'Object'", @quoter.quote(Object)
       end
 
-      def test_crazy_object
-        crazy = Object.new
+      def test_quote_object_instance
+        object = Object.new
         e = assert_raises(TypeError) do
-          @quoter.quote(crazy)
+          @quoter.quote(object)
         end
         assert_equal "can't quote Object", e.message
       end
@@ -203,13 +198,14 @@ module ActiveRecord
       end
 
       def test_quote_duration
-        assert_equal "1800", @quoter.quote(30.minutes)
+        exception = assert_raises(TypeError) { @quoter.quote(30.minutes) }
+        assert_equal "can't quote ActiveSupport::Duration", exception.message
       end
     end
 
     class TypeCastingTest < ActiveRecord::TestCase
       def setup
-        @conn = ActiveRecord::Base.connection
+        @conn = ActiveRecord::Base.lease_connection
       end
 
       def test_type_cast_symbol
@@ -218,7 +214,7 @@ module ActiveRecord
 
       def test_type_cast_date
         date = Date.today
-        if current_adapter?(:Mysql2Adapter)
+        if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
           expected = date
         else
           expected = @conn.quoted_date(date)
@@ -228,7 +224,7 @@ module ActiveRecord
 
       def test_type_cast_time
         time = Time.now
-        if current_adapter?(:Mysql2Adapter)
+        if current_adapter?(:Mysql2Adapter, :TrilogyAdapter)
           expected = time
         else
           expected = @conn.quoted_date(time)
@@ -249,11 +245,15 @@ module ActiveRecord
         obj = Class.new.new
         assert_raise(TypeError) { @conn.type_cast(obj) }
       end
+
+      def test_type_cast_duration_should_raise_error
+        assert_raise(TypeError) { @conn.type_cast(1.hour) }
+      end
     end
 
     class QuoteBooleanTest < ActiveRecord::TestCase
       def setup
-        @connection = ActiveRecord::Base.connection
+        @connection = ActiveRecord::Base.lease_connection
       end
 
       def test_quote_returns_frozen_string
@@ -266,38 +266,5 @@ module ActiveRecord
         assert_predicate @connection.type_cast(false), :frozen?
       end
     end
-
-    if supports_datetime_with_precision?
-      class QuoteARBaseTest < ActiveRecord::TestCase
-        class DatetimePrimaryKey < ActiveRecord::Base
-        end
-
-        def setup
-          @time = ::Time.utc(2017, 2, 14, 12, 34, 56, 789999)
-          @connection = ActiveRecord::Base.connection
-          @connection.create_table :datetime_primary_keys, id: :datetime, precision: 3, force: true
-        end
-
-        def teardown
-          @connection.drop_table :datetime_primary_keys, if_exists: true
-        end
-
-        def test_quote_ar_object
-          value = DatetimePrimaryKey.new(id: @time)
-          expected = "'2017-02-14 12:34:56.789000'"
-          assert_deprecated do
-            assert_equal expected, @connection.quote(value)
-          end
-        end
-
-        def test_type_cast_ar_object
-          value = DatetimePrimaryKey.new(id: @time)
-          expected = @connection.type_cast(value.id)
-          assert_deprecated do
-            assert_equal expected, @connection.type_cast(value)
-          end
-        end
-      end
-    end
   end
 end

data/test/cases/readonly_test.rb

@@ -37,19 +37,61 @@ class ReadOnlyTest < ActiveRecord::TestCase
     assert_equal "Developer is marked as readonly", e.message
   end
 
+  def test_cant_touch_readonly_record
+    dev = Developer.find(1)
+    assert_not_predicate dev, :readonly?
+
+    dev.readonly!
+    assert_predicate dev, :readonly?
+
+    e = assert_raise(ActiveRecord::ReadOnlyRecord) { dev.touch  }
+    assert_equal "Developer is marked as readonly", e.message
+  end
+
+  def test_cant_touch_readonly_column
+    person = Person.find(1)
+
+    e = assert_raise(ActiveRecord::ActiveRecordError) { person.touch(:born_at)  }
+    assert_equal "born_at is marked as readonly", e.message
+  end
+
+  def test_cant_update_column_readonly_record
+    dev = Developer.find(1)
+    assert_not_predicate dev, :readonly?
+
+    dev.readonly!
+    assert_predicate dev, :readonly?
+
+    e = assert_raise(ActiveRecord::ReadOnlyRecord) { dev.update_column(:name, "New name")  }
+    assert_equal "Developer is marked as readonly", e.message
+  end
+
+  def test_cant_update_columns_readonly_record
+    dev = Developer.find(1)
+    assert_not_predicate dev, :readonly?
+
+    dev.readonly!
+    assert_predicate dev, :readonly?
+
+    e = assert_raise(ActiveRecord::ReadOnlyRecord) { dev.update_columns(name: "New name")  }
+    assert_equal "Developer is marked as readonly", e.message
+  end
+
   def test_find_with_readonly_option
     Developer.all.each { |d| assert_not d.readonly? }
+    Developer.all.tap { |rel| assert_not rel.readonly? }
     Developer.readonly(false).each { |d| assert_not d.readonly? }
-    Developer.readonly(true).each { |d| assert d.readonly? }
-    Developer.readonly.each { |d| assert d.readonly? }
+    Developer.readonly(true).each { |d| assert_predicate d, :readonly? }
+    Developer.readonly.each { |d| assert_predicate d, :readonly? }
+    Developer.readonly.tap { |rel| assert_predicate rel, :readonly? }
   end
 
   def test_find_with_joins_option_does_not_imply_readonly
     Developer.joins("  ").each { |d| assert_not d.readonly? }
-    Developer.joins("  ").readonly(true).each { |d| assert d.readonly? }
+    Developer.joins("  ").readonly(true).each { |d| assert_predicate d, :readonly? }
 
     Developer.joins(", projects").each { |d| assert_not d.readonly? }
-    Developer.joins(", projects").readonly(true).each { |d| assert d.readonly? }
+    Developer.joins(", projects").readonly(true).each { |d| assert_predicate d, :readonly? }
   end
 
   def test_has_many_find_readonly
@@ -90,14 +132,10 @@ class ReadOnlyTest < ActiveRecord::TestCase
       assert_not_predicate Post.readonly(false).find(1), :readonly?
     end
 
-    # Oracle barfs on this because the join includes unqualified and
-    # conflicting column names
-    unless current_adapter?(:OracleAdapter)
-      Post.joins(", developers").scoping do
-        assert_not_predicate Post.find(1), :readonly?
-        assert_predicate Post.readonly.find(1), :readonly?
-        assert_not_predicate Post.readonly(false).find(1), :readonly?
-      end
+    Post.joins(", developers").scoping do
+      assert_not_predicate Post.find(1), :readonly?
+      assert_predicate Post.readonly.find(1), :readonly?
+      assert_not_predicate Post.readonly(false).find(1), :readonly?
     end
 
     Post.readonly(true).scoping do

data/test/cases/reaper_test.rb

@@ -59,7 +59,7 @@ module ActiveRecord
 
       def test_pool_has_reaper
         config = ActiveRecord::Base.configurations.configs_for(env_name: "arunit", name: "primary")
-        pool_config = PoolConfig.new(ActiveRecord::Base, config)
+        pool_config = PoolConfig.new(ActiveRecord::Base, config, :writing, :default)
         pool = ConnectionPool.new(pool_config)
 
         assert pool.reaper
@@ -118,8 +118,10 @@ module ActiveRecord
         pool = ConnectionPool.new(pool_config)
 
         pool.discard!
-        pool.reap
-        pool.flush
+        assert_nothing_raised do
+          pool.reap
+          pool.flush
+        end
       end
 
       if Process.respond_to?(:fork)
@@ -128,13 +130,20 @@ module ActiveRecord
           pool = ConnectionPool.new(pool_config)
           pool.checkout
 
+          # We currently have a bug somewhere which leads for this test case to be deadlocked
+          # and timeout after 30 minutes on the CI. Until that bug is fixed, this test is made
+          # to timeout after a short period of time to reduce the damage.
+          reader, writer = IO.pipe
+
           pid = fork do
+            reader.close
             pool = ConnectionPool.new(pool_config)
 
             conn, child = new_conn_in_thread(pool)
             child.terminate
 
             wait_for_conn_idle(conn)
+            writer.close
             if conn.in_use?
               exit!(1)
             else
@@ -142,8 +151,14 @@ module ActiveRecord
             end
           end
 
-          Process.waitpid(pid)
-          assert $?.success?
+          writer.close
+          completed = reader.wait_readable(20)
+          reader.close
+          unless completed
+            Process.kill("ABRT", pid)
+          end
+          _, status = Process.wait2(pid)
+          assert_predicate status, :success?
         ensure
           pool.discard!
         end
@@ -171,7 +186,7 @@ module ActiveRecord
         def duplicated_pool_config(merge_config_options = {})
           old_config = ActiveRecord::Base.connection_pool.db_config.configuration_hash.merge(merge_config_options)
           db_config = ActiveRecord::DatabaseConfigurations::HashConfig.new("arunit", "primary", old_config.dup)
-          PoolConfig.new(ActiveRecord::Base, db_config)
+          PoolConfig.new(ActiveRecord::Base, db_config, :writing, :default)
         end
 
         def new_conn_in_thread(pool)
@@ -180,6 +195,7 @@ module ActiveRecord
 
           child = Thread.new do
             conn = pool.checkout
+            conn.query("SELECT 1") # ensure connected
             event.set
             Thread.stop
           end