Refactor slightly how to wait for things during tests

And wait until all semaphores have been signalled, as it might happen that
jobs finish and before they've signaled the semaphore, we try to wait on it,
having the test fail, if the timing aligns.

Author: rosa

test/integration/concurrency_controls_test.rb

@@ -89,6 +89,7 @@ class ConcurrencyControlsTest < ActiveSupport::TestCase
     wait_for_jobs_to_finish_for(3.seconds)
     assert_no_pending_jobs
 
+    wait_while_with_timeout(1.second) { SolidQueue::Semaphore.where(value: 0).any? }
     # Lock the semaphore so we can enqueue jobs and leave them blocked
     skip_active_record_query_cache do
       assert SolidQueue::Semaphore.wait(job)
@@ -121,6 +122,7 @@ class ConcurrencyControlsTest < ActiveSupport::TestCase
     wait_for_jobs_to_finish_for(3.seconds)
     assert_no_pending_jobs
 
+    wait_while_with_timeout(1.second) { SolidQueue::Semaphore.where(value: 0).any? }
     # Lock the semaphore so we can enqueue jobs and leave them blocked
     skip_active_record_query_cache do
       assert SolidQueue::Semaphore.wait(job)

test/integration/processes_lifecycle_test.rb

@@ -8,7 +8,7 @@ class ProcessLifecycleTest < ActiveSupport::TestCase
   setup do
     @pid = run_supervisor_as_fork
 
-    wait_for_registered_processes(3, timeout: 0.2.second)
+    wait_for_registered_processes(3, timeout: 1.second)
     assert_registered_workers_for(:background, :default)
   end
 

test/test_helper.rb

@@ -36,14 +36,7 @@ class ActiveSupport::TestCase
 
   private
     def wait_for_jobs_to_finish_for(timeout = 1.second)
-      skip_active_record_query_cache do
-        Timeout.timeout(timeout) do
-          while SolidQueue::Job.where(finished_at: nil).any? do
-            sleep 0.05
-          end
-        end
-      end
-    rescue Timeout::Error
+      wait_while_with_timeout(timeout) { SolidQueue::Job.where(finished_at: nil).any? }
     end
 
     def assert_no_pending_jobs
@@ -59,12 +52,7 @@ def run_supervisor_as_fork(**options)
     end
 
     def wait_for_registered_processes(count, timeout: 1.second)
-      Timeout.timeout(timeout) do
-        while SolidQueue::Process.count != count do
-          sleep 0.05
-        end
-      end
-    rescue Timeout::Error
+      wait_while_with_timeout(timeout) { SolidQueue::Process.count != count }
     end
 
     def assert_no_registered_processes
@@ -86,14 +74,27 @@ def terminate_process(pid, timeout: 10, signal: :TERM)
 
     def wait_for_process_termination_with_timeout(pid, timeout: 10, exitstatus: 0)
       Timeout.timeout(timeout) do
-        Process.waitpid(pid)
-        assert exitstatus, $?.exitstatus
+        if process_exists?(pid)
+          Process.waitpid(pid)
+          assert exitstatus, $?.exitstatus
+        end
       end
     rescue Timeout::Error
       signal_process(pid, :KILL)
       raise
     end
 
+    def wait_while_with_timeout(timeout, &block)
+      Timeout.timeout(timeout) do
+        skip_active_record_query_cache do
+          while block.call
+            sleep 0.05
+          end
+        end
+      end
+    rescue Timeout::Error
+    end
+
     def signal_process(pid, signal, wait: nil)
       Thread.new do
         sleep(wait) if wait