fix: never wait a negative retry interval

A synchronous lock retry computed its wait from the remaining deadline, which can go negative between the expiry check and the wait, raising ArgumentError instead of the SyncEnqueueTimeout the caller expected. Skip the wait when no interval remains. The new compatibility matrix surfaced this on its first run.

Author: cardmagic

CHANGELOG.md

@@ -6,6 +6,10 @@
   against Rails 8.0 and 8.1. The suite previously ran on one combination, so
   `>= 8.0` was a claim rather than a tested guarantee. Set `RAILS_VERSION` to
   pin a Rails line locally.
+- Stop a synchronous lock retry from asking for a negative wait when its
+  deadline expires between the check and the wait, which raised
+  `ArgumentError: time interval must not be negative` instead of the timeout
+  the caller expected. Found by the new compatibility matrix.
 
 ## Unreleased
 

lib/solid_objects/database_adapters/sqlite.rb

@@ -160,13 +160,15 @@ def wait_before_busy_retry(attempts)
         end
       end
 
+      # The deadline can expire between the check above and this wait, which
+      # would otherwise ask for a negative interval.
       # @rbs () -> void
       def wait_before_retry
+        interval = [ LOCK_RETRY_INTERVAL, SyncDeadline.remaining ].min
+        return unless interval.positive?
+
         LOCK_RETRY_MUTEX.synchronize do
-          LOCK_RETRY_CONDITION.wait(
-            LOCK_RETRY_MUTEX,
-            [ LOCK_RETRY_INTERVAL, SyncDeadline.remaining ].min
-          )
+          LOCK_RETRY_CONDITION.wait(LOCK_RETRY_MUTEX, interval)
         end
       end
     end

sig/generated/lib/solid_objects/database_adapters/sqlite.rbs

@@ -52,6 +52,8 @@ module SolidObjects
       # @rbs (Integer) -> void
       def wait_before_busy_retry: (Integer) -> void
 
+      # The deadline can expire between the check above and this wait, which
+      # would otherwise ask for a negative interval.
       # @rbs () -> void
       def wait_before_retry: () -> void
     end

test/integration/synchronous_invocation_test.rb

@@ -552,6 +552,15 @@ def wait(timeout:)
       "a synchronous call should read the clock once per transaction, not once per step"
   end
 
+  test "a retry wait whose deadline already expired does not raise" do
+    skip unless SolidObjects::Record.connection.adapter_name.match?(/sqlite/i)
+    adapter = SolidObjects.database_adapter
+
+    SolidObjects::SyncDeadline.with(timeout: -1) do
+      assert_nothing_raised { adapter.send(:wait_before_retry) }
+    end
+  end
+
   test "sync discovers the configured SQLite busy wait it has to restore" do
     skip unless SolidObjects::Record.connection.adapter_name.match?(/sqlite/i)