test: stop stripping the SQLite busy handler

The doctor and synchronous invocation suites each simulated immediate lock failure by writing PRAGMA busy_timeout back over itself, which left the pooled connection with no busy handler and made later concurrent tests fail with SQLite3::BusyException. Share one helper that suspends and correctly restores the configured busy wait.

Author: cardmagic

test/database_test_helper.rb

@@ -56,6 +56,31 @@ class ActiveSupport::TestCase
     SolidObjects::Process.delete_all
     SolidObjectsTestDomainRecord.delete_all
   end
+
+  def with_immediate_sqlite_lock_failure(&block)
+    SolidObjects::Record.connection_pool.with_connection do |connection|
+      suspend_sqlite_busy_wait(connection, &block)
+    end
+  end
+
+  def suspend_sqlite_busy_wait(connection)
+    database_adapter = SolidObjects.database_adapter
+    database_adapter.define_singleton_method(:configured_busy_handler_timeout) { |_connection| 0 }
+    connection.raw_connection.busy_handler_timeout = 0
+    yield
+  ensure
+    database_adapter.singleton_class.send(:remove_method, :configured_busy_handler_timeout)
+    connection.raw_connection.busy_handler_timeout = configured_sqlite_busy_handler_timeout
+  end
+
+  def configured_sqlite_busy_handler_timeout
+    SolidObjects::Record
+      .connection_pool
+      .db_config
+      .configuration_hash
+      .fetch(:timeout, 5_000)
+      .to_i
+  end
 end
 
 Minitest.after_run do

test/integration/doctor_test.rb

@@ -52,7 +52,7 @@ class DoctorTest < ActiveSupport::TestCase
     skip unless SolidObjects::Record.connection.adapter_name.match?(/sqlite/i)
     lock = hold_sqlite_write_lock
 
-    report = without_sqlite_busy_wait { SolidObjects::Doctor.new.call }
+    report = with_immediate_sqlite_lock_failure { SolidObjects::Doctor.new.call }
 
     refute report.healthy?
     assert_equal :fail, report.check(:sync_round_trip).status
@@ -171,16 +171,6 @@ def hold_sqlite_write_lock
     [ thread, release ]
   end
 
-  def without_sqlite_busy_wait
-    SolidObjects::Record.connection_pool.with_connection do |connection|
-      previous_timeout = connection.select_value("PRAGMA busy_timeout").to_i
-      connection.execute("PRAGMA busy_timeout = 0")
-      yield
-    ensure
-      connection.execute("PRAGMA busy_timeout = #{previous_timeout}") if previous_timeout
-    end
-  end
-
   def release_sqlite_write_lock(lock)
     thread, release = lock
     release << true

test/integration/synchronous_invocation_test.rb

@@ -806,7 +806,7 @@ def invoke_with_immediate_sqlite_lock_failure(message_reference)
         attempts += 1 if process_write?(event.payload)
       end
       SolidObjects::Record.connection_pool.with_connection do |connection|
-        with_immediate_sqlite_lock_failure(connection) do
+        suspend_sqlite_busy_wait(connection) do
           started_at = monotonic_now
           error = capture_exception do
             SolidObjects::SynchronousInvocation.new.call(message_reference, timeout: 0.1)
@@ -823,25 +823,6 @@ def invoke_with_immediate_sqlite_lock_failure(message_reference)
     captured
   end
 
-  def with_immediate_sqlite_lock_failure(connection)
-    database_adapter = SolidObjects.database_adapter
-    database_adapter.define_singleton_method(:configured_busy_handler_timeout) { |_connection| 0 }
-    connection.raw_connection.busy_handler_timeout = 0
-    yield
-  ensure
-    database_adapter.singleton_class.send(:remove_method, :configured_busy_handler_timeout)
-    connection.raw_connection.busy_handler_timeout = configured_busy_handler_timeout
-  end
-
-  def configured_busy_handler_timeout
-    SolidObjects::Record
-      .connection_pool
-      .db_config
-      .configuration_hash
-      .fetch(:timeout, 5_000)
-      .to_i
-  end
-
   def process_write?(payload)
     payload.fetch(:sql).match?(/\A(?:INSERT|UPDATE)/) &&
       payload.fetch(:sql).include?(SolidObjects::Process.table_name)