Tidy up tests, grouping some helpers together

Author: rosa

test/dummy/config/environments/test.rb

@@ -16,6 +16,8 @@
   # system, or in some way before deploying your code.
   config.eager_load = ENV["CI"].present?
 
+  config.autoload_paths += %w[ test/test_helpers ]
+
   # Configure public file server for tests with Cache-Control for performance.
   config.public_file_server.enabled = true
   config.public_file_server.headers = {

test/helpers/.keep

@@ -316,10 +316,4 @@ def assert_job_status(active_job, status)
         assert job.public_send("#{status}?")
       end
     end
-
-    def assert_no_claimed_jobs
-      skip_active_record_query_cache do
-        assert SolidQueue::ClaimedExecution.none?
-      end
-    end
 end

test/integration/forked_processes_lifecycle_test.rb

@@ -78,10 +78,6 @@ class RecurringTasksTest < ActiveSupport::TestCase
   end
 
   private
-    def wait_for_jobs_to_be_enqueued(count, timeout: 1.second)
-      wait_while_with_timeout(timeout) { SolidQueue::Job.count < count }
-    end
-
     def assert_recurring_tasks(expected_tasks)
       skip_active_record_query_cache do
         assert_equal expected_tasks.count, SolidQueue::RecurringTask.count

test/integration/recurring_tasks_test.rb

@@ -26,6 +26,8 @@ def write(...)
 Logger::LogDevice.prepend(BlockLogDeviceTimeoutExceptions)
 
 class ActiveSupport::TestCase
+  include ProcessesTestHelper, JobsTestHelper
+
   teardown do
     JobBuffer.clear
 
@@ -43,57 +45,6 @@ class ActiveSupport::TestCase
   end
 
   private
-    def wait_for_jobs_to_finish_for(timeout = 1.second, except: [])
-      wait_while_with_timeout(timeout) do
-        SolidQueue::Job.where.not(active_job_id: Array(except).map(&:job_id)).where(finished_at: nil).any?
-      end
-    end
-
-    def assert_no_unfinished_jobs
-      skip_active_record_query_cache do
-        assert SolidQueue::Job.where(finished_at: nil).none?
-      end
-    end
-
-    def run_supervisor_as_fork(**options)
-      fork do
-        SolidQueue::Supervisor.start(mode: :fork, **options)
-      end
-    end
-
-    def wait_for_registered_processes(count, timeout: 1.second)
-      wait_while_with_timeout(timeout) { SolidQueue::Process.count != count }
-    end
-
-    def assert_no_registered_processes
-      skip_active_record_query_cache do
-        assert SolidQueue::Process.none?
-      end
-    end
-
-    def find_processes_registered_as(kind)
-      skip_active_record_query_cache do
-        SolidQueue::Process.where(kind: kind)
-      end
-    end
-
-    def terminate_process(pid, timeout: 10, signal: :TERM)
-      signal_process(pid, signal)
-      wait_for_process_termination_with_timeout(pid, timeout: timeout)
-    end
-
-    def wait_for_process_termination_with_timeout(pid, timeout: 10, exitstatus: 0)
-      Timeout.timeout(timeout) do
-        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)
       wait_while_with_timeout!(timeout, &block)
     rescue Timeout::Error
@@ -109,26 +60,6 @@ def wait_while_with_timeout!(timeout, &block)
       end
     end
 
-    def signal_process(pid, signal, wait: nil)
-      Thread.new do
-        sleep(wait) if wait
-        Process.kill(signal, pid)
-      end
-    end
-
-    def process_exists?(pid)
-      reap_processes
-      Process.getpgid(pid)
-      true
-    rescue Errno::ESRCH
-      false
-    end
-
-    def reap_processes
-      Process.waitpid(-1, Process::WNOHANG)
-    rescue Errno::ECHILD
-    end
-
     # Allow skipping AR query cache, necessary when running test code in multiple
     # forks. The queries done in the test might be cached and if we don't perform
     # any non-SELECT queries after previous SELECT queries were cached on the connection

test/test_helper.rb

@@ -0,0 +1,31 @@
+module JobsTestHelper
+  private
+
+  def wait_for_jobs_to_finish_for(timeout = 1.second, except: [])
+    wait_while_with_timeout(timeout) do
+      skip_active_record_query_cache do
+        SolidQueue::Job.where.not(active_job_id: Array(except).map(&:job_id)).where(finished_at: nil).any?
+      end
+    end
+  end
+
+  def assert_no_unfinished_jobs
+    skip_active_record_query_cache do
+      assert SolidQueue::Job.where(finished_at: nil).none?
+    end
+  end
+
+  def wait_for_jobs_to_be_enqueued(count, timeout: 1.second)
+    wait_while_with_timeout(timeout) do
+      skip_active_record_query_cache do
+        SolidQueue::Job.count < count
+      end
+    end
+  end
+
+  def assert_no_claimed_jobs
+    skip_active_record_query_cache do
+      assert SolidQueue::ClaimedExecution.none?
+    end
+  end
+end

test/test_helpers/jobs_test_helper.rb

@@ -0,0 +1,83 @@
+module ProcessesTestHelper
+  private
+
+  def run_supervisor_as_fork(**options)
+    fork do
+      SolidQueue::Supervisor.start(mode: :fork, **options)
+    end
+  end
+
+  def wait_for_registered_processes(count, timeout: 1.second)
+    wait_while_with_timeout(timeout) { SolidQueue::Process.count != count }
+  end
+
+  def assert_no_registered_processes
+    skip_active_record_query_cache do
+      assert SolidQueue::Process.none?
+    end
+  end
+
+  def assert_registered_processes(kind:, count: 1, supervisor_pid: nil, **attributes)
+    processes = skip_active_record_query_cache { SolidQueue::Process.where(kind: kind).to_a }
+    assert_equal count, processes.count
+
+    if supervisor_pid
+      processes.each do |process|
+        assert_equal supervisor_pid, process.supervisor.pid
+      end
+    end
+
+    attributes.each do |attr, value|
+      processes.each do |process|
+        if value.present?
+          assert_equal value, process.public_send(attr)
+        else
+          assert_nil process.public_send(attr)
+        end
+      end
+    end
+  end
+
+  def find_processes_registered_as(kind)
+    skip_active_record_query_cache do
+      SolidQueue::Process.where(kind: kind)
+    end
+  end
+
+  def terminate_process(pid, timeout: 10, signal: :TERM)
+    signal_process(pid, signal)
+    wait_for_process_termination_with_timeout(pid, timeout: timeout)
+  end
+
+  def wait_for_process_termination_with_timeout(pid, timeout: 10, exitstatus: 0)
+    Timeout.timeout(timeout) do
+      if process_exists?(pid)
+        Process.waitpid(pid)
+        assert exitstatus, $?.exitstatus
+      end
+    end
+  rescue Timeout::Error
+    signal_process(pid, :KILL)
+    raise
+  end
+
+  def signal_process(pid, signal, wait: nil)
+    Thread.new do
+      sleep(wait) if wait
+      Process.kill(signal, pid)
+    end
+  end
+
+  def process_exists?(pid)
+    reap_processes
+    Process.getpgid(pid)
+    true
+  rescue Errno::ESRCH
+    false
+  end
+
+  def reap_processes
+    Process.waitpid(-1, Process::WNOHANG)
+  rescue Errno::ECHILD
+  end
+end

test/test_helpers/processes_test_helper.rb

@@ -61,17 +61,4 @@ class AsyncSupervisorTest < ActiveSupport::TestCase
     def run_supervisor_async(**kwargs)
       SolidQueue::Supervisor.start(mode: :async, **kwargs)
     end
-
-    def assert_registered_processes(kind:, supervisor_id: nil, count: 1)
-      processes = SolidQueue::Process.where(kind: kind)
-      assert_equal count, processes.count
-
-      processes.each do |process|
-        if supervisor_id.present?
-          assert_equal supervisor_id, process.supervisor_id
-        else
-          assert_nil process.supervisor_id
-        end
-      end
-    end
 end

test/unit/async_supervisor_test.rb

@@ -100,11 +100,10 @@ class DispatcherTest < ActiveSupport::TestCase
     @dispatcher.start
     another_dispatcher.start
 
-    sleep(0.7.seconds)
+    wait_while_with_timeout(1.second) { SolidQueue::ScheduledExecution.any? }
 
     assert_equal 0, SolidQueue::ScheduledExecution.count
     assert_equal 15, SolidQueue::ReadyExecution.count
-
   ensure
     another_dispatcher&.stop
   end

test/unit/dispatcher_test.rb

@@ -137,15 +137,6 @@ def assert_registered_dispatcher(supervisor_pid: nil)
       assert_registered_processes(kind: "Dispatcher", count: 1, supervisor_pid: supervisor_pid)
     end
 
-    def assert_registered_processes(kind:, supervisor_pid:, count: 1)
-      processes = find_processes_registered_as(kind)
-      assert_equal count, processes.count
-
-      processes.each do |process|
-        assert_equal supervisor_pid, process.supervisor.pid
-      end
-    end
-
     def assert_registered_supervisor(pid)
       skip_active_record_query_cache do
         processes = find_processes_registered_as("Supervisor(fork)")