minitest-parallel_fork 2.0.0 → 2.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2698fbcfb5e14bed9fbf23e2abe38c5395b615f4443e335ce606b2f674883e30
-  data.tar.gz: dff7fbdc3104a729405415688ff35e574d65df94ac0c2086f3791e5005a95dfd
+  metadata.gz: d3ea39201143c49a9886a6d8e088534321ec4083d1b1e1cbf80dbcf2a805f912
+  data.tar.gz: 8d09b179947dad7aba1db8d67db6bc4ba578e5ac2a0ece7a28645cdfffd67de6
 SHA512:
-  metadata.gz: 80b75938b994edb1f6cfe17c5b8ad31550ab6081738f178ac3dd3c991a7a61fd1a6730d0e855cec3d1d0f5113dddda6ecec455f310ccf4ebcc74298a763a43ae
-  data.tar.gz: 398db64ae6468875db78f49ba7221f8cb1f789161adf361a2125daee43a85acd194c0afbbeb1faab35290c72bc377b4eba1cd01dbfba9ace41255d6278eb4a5b
+  metadata.gz: 84070499e66a0c2b5e1fb9e4dcd9d2d773a73812f35c0c55796ced661a61af1361ab10e1825f19fba4a7ea538f02d11e9a8df50d57d4f27b48eaea5d0ff6ef05
+  data.tar.gz: 3cbd02252db159fcaeeb85f6caed1c979b36af36fc57a44c0775929f71eaf3a213d2c4457644f331214fb2433e09589933b6ec415df82da4513f601336193bdf

data/CHANGELOG

@@ -1,3 +1,11 @@
+=== 2.1.1 (2025-12-18)
+
+* Work with minitest 6+ (jeremyevans)
+
+=== 2.1.0 (2025-07-02)
+
+* Add minitest/parallel_fork/interrupt with support handling interrupts (stackmystack, jeremyevans) (#14)
+
 === 2.0.0 (2023-11-08)
 
 * Avoid method redefined warning in verbose warning mode (jeremyevans)

data/README.rdoc

@@ -79,6 +79,20 @@ Note that minitest-parallel_fork uses suite-based parallelism, so tests will not
 stop until one child has a failing test suite (test class that has a failing test
 method), and other children are signaled and also stop processing.
 
+== Interrupt Support
+
+If you would like to run tests in parallel, but allow for shutting down children
+when SIGINT is sent to the process, you can use:
+
+  RUBYOPT=-rminitest/parallel_fork/interrupt ruby spec_runner.rb
+
+The first SIGINT to a process will ask the child processes to shut down gracefully
+with SIGUSR1.  The second SIGINT to a process will kill the child processes with
+SIGKILL.
+
+Note that if you use rake to run the specs, the second SIGINT may not be sent to
+to the parent process, as rake does it's own SIGINT handling.
+
 == ActiveRecord
 
 To use this with Rails/ActiveRecord, you probably want to use hooks similar to:
@@ -105,6 +119,11 @@ specs:
   spec_sqlite:    1.75x - 1.86x   2.26x - 2.65x
   spec_postgres:  1.32x - 1.40x     Untested
 
+= Known Issues
+
+When using with minitest 6 and minitest-hooks, reported assertion counts may be
+inaccurate, though run, failure, and error counts should still be accurate.
+
 = License
 
 MIT

data/lib/minitest/parallel_fork/fail_fast.rb

@@ -1,69 +1,17 @@
+require_relative 'halt'
 require_relative '../parallel_fork'
 
 module Minitest::ParalleForkFailFast
-  def run_after_parallel_fork_hook(i)
-    super
-    Signal.trap(:USR1) do
-      @parallel_fork_stop = true
-    end
-  end
-
-  def parallel_fork_data_to_marshal
-    super << @parallel_fork_stop
-  end
-
-  def parallel_fork_data_from_marshal(data)
-    data = Marshal.load(data)
-    @parallel_fork_stop = true if data.pop
-    data
-  end
-
-  def parallel_fork_run_test_suites(suites, reporter, options)
-    suites.each do |suite|
-      parallel_fork_run_test_suite(suite, reporter, options)
-
-      # Fail fast if this child process had a failure,
-      # Or the USR1 signal was received indicating other child processes had a failure.
-      break if @parallel_fork_stop
-    end
-  end
+  include Minitest::ParallelForkHalt
 
   def parallel_fork_run_test_suite(suite, reporter, options)
     super
 
-
     if parallel_fork_stat_reporter.results.any?{|r| !r.failure.is_a?(Minitest::Skip)}
       # At least one failure or error, mark as failing fast
       @parallel_fork_stop = true
     end
   end
-
-  def parallel_fork_child_data(data)
-    threads = {}
-    data.each{|pid, read| threads[pid] = Thread.new(read, &:read)}
-    results = []
-
-    while sleep(0.01) && !threads.empty?
-      threads.to_a.each do |pid, thread|
-        unless thread.alive?
-          threads.delete(pid)
-          results << parallel_fork_data_from_marshal(thread.value)
-
-          if @parallel_fork_stop
-            # If any child failed fast, signal other children to fail fast
-            threads.each_key do |pid|
-              Process.kill(:USR1, pid)
-            end
-
-            # Set a flag indicating that all child processes have been signaled
-            @parallel_fork_stop = :FINISHED
-          end
-        end
-      end
-    end
-
-    results
-  end
 end
 
 Minitest.singleton_class.prepend(Minitest::ParalleForkFailFast)

data/lib/minitest/parallel_fork/halt.rb

@@ -0,0 +1,55 @@
+module Minitest::ParallelForkHalt
+  def run_after_parallel_fork_hook(i)
+    super
+    Signal.trap(:USR1) do
+      @parallel_fork_stop = true
+    end
+  end
+
+  def parallel_fork_data_to_marshal
+    super << @parallel_fork_stop
+  end
+
+  def parallel_fork_data_from_marshal(data)
+    data = Marshal.load(data)
+    @parallel_fork_stop = true if data.pop
+    data
+  end
+
+  def parallel_fork_run_test_suites(suites, reporter, options)
+    suites.each do |suite|
+      parallel_fork_run_test_suite(suite, reporter, options)
+
+      # Halt if this child process requested an exit,
+      # Or other child processes requested an exit.
+      break if @parallel_fork_stop
+    end
+  end
+
+  def parallel_fork_child_data(data)
+    threads = {}
+    data.each{|pid, read| threads[pid] = Thread.new(read, &:read)}
+    results = []
+
+    while sleep(0.01) && !threads.empty?
+      threads.to_a.each do |pid, thread|
+        unless thread.alive?
+          threads.delete(pid)
+          results << parallel_fork_data_from_marshal(thread.value)
+
+          if @parallel_fork_stop
+            # If halt is requested, signal other children to halt
+            threads.each_key do |pid|
+              Process.kill(:USR1, pid)
+            end
+
+            # Set a flag indicating that all child processes have been signaled
+            @parallel_fork_stop = :FINISHED
+          end
+        end
+      end
+    end
+
+    results
+  end
+end

data/lib/minitest/parallel_fork/interrupt.rb

@@ -0,0 +1,45 @@
+require 'minitest'
+
+require_relative 'halt'
+require_relative '../parallel_fork'
+
+module Minitest
+  @parallel_fork_child_pids = []
+end
+
+module Minitest::ParallelForkInterrupt
+  include Minitest::ParallelForkHalt
+
+  def run_before_parallel_fork_hook
+    Signal.trap(:INT) do
+      Signal.trap(:INT) do
+        parallel_fork_kill_all :KILL
+      end
+      $stderr.puts "\nInterrupted.\nExiting ...\nInterrupt again to exit immediately."
+      parallel_fork_kill_all :USR1
+    end
+  end
+
+  def run_after_parallel_fork_hook(i)
+    super
+    Signal.trap(:INT, 'IGNORE')
+  end
+
+  def parallel_fork_fork_child(i, suites, reporter, options)
+    res = super
+    @parallel_fork_child_pids << res[0]
+    res
+  end
+
+  def parallel_fork_kill_all(signal)
+    @parallel_fork_child_pids.each do |pid|
+      begin
+        Process.kill(signal, pid)
+      rescue Errno::ESRCH
+        # Process already terminated
+      end
+    end
+  end
+end
+
+Minitest.singleton_class.prepend(Minitest::ParallelForkInterrupt)

data/lib/minitest/parallel_fork.rb

@@ -1,7 +1,10 @@
 require 'minitest'
 
 module Minitest::Unparallelize
-  define_method(:run_one_method, &Minitest::Test.method(:run_one_method))
+ # :nocov:
+ meth = Minitest::VERSION >= '6' ? :run : :run_one_method
+ # :nocov:
+ define_method(meth, &Minitest::Test.method(meth))
 end
 
 module Minitest
@@ -74,30 +77,40 @@ class << Minitest
       suite.extend(Minitest::Unparallelize)
     end
 
-    suite.run(reporter, options)
+    if Minitest::VERSION >= '6'
+      suite.run_suite(reporter, options)
+    # :nocov:
+    else
+      suite.run(reporter, options)
+    end
+    # :nocov:
   end
 
   def parallel_fork_setup_children(suites, reporter, options)
     set_parallel_fork_stat_reporter(reporter)
     run_before_parallel_fork_hook
 
-    n = parallel_fork_number
-    n.times.map do |i|
-      read, write = IO.pipe.each{|io| io.binmode}
-      pid = Process.fork do
-        read.close
-        run_after_parallel_fork_hook(i)
+    parallel_fork_number.times.map do |i|
+      parallel_fork_fork_child(i, suites, reporter, options)
+    end
+  end
+
+  def parallel_fork_fork_child(i, suites, reporter, options)
+    read, write = IO.pipe.each{|io| io.binmode}
+    pid = Process.fork do
+      read.close
+      run_after_parallel_fork_hook(i)
 
-        p_suites = []
-        suites.each_with_index{|s, j| p_suites << s if j % n == i}
-        parallel_fork_run_test_suites(p_suites, reporter, options)
+      p_suites = []
+      n = parallel_fork_number
+      suites.each_with_index{|s, j| p_suites << s if j % n == i}
+      parallel_fork_run_test_suites(p_suites, reporter, options)
 
-        write.write(Marshal.dump(parallel_fork_data_to_marshal))
-        write.close
-      end
+      write.write(Marshal.dump(parallel_fork_data_to_marshal))
       write.close
-      [pid, read]
     end
+    write.close
+    [pid, read]
   end
 
   def parallel_fork_child_data(data)
@@ -120,12 +133,16 @@ class << Minitest
     (ENV['NCPU'] || 4).to_i
   end
 
+  # :nocov:
+  run_method = Minitest::VERSION >= '6' ? :run_all_suites : :__run
+  # :nocov:
+
   # Avoid method redefined verbose warning
-  alias __run __run
+  alias_method run_method, run_method
 
   # Override __run to use a child forks to run the speeds, which
   # allows for parallel spec execution on MRI.
-  def __run(reporter, options)
+  define_method(run_method) do |reporter, options|
     parallel_fork_wait_for_children(parallel_fork_setup_children(parallel_fork_suites, reporter, options), reporter)
     nil
   end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: minitest-parallel_fork
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.1
 platform: ruby
 authors:
 - Jeremy Evans
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-11-08 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -63,15 +62,17 @@ email: code@jeremyevans.net
 executables: []
 extensions: []
 extra_rdoc_files:
-- README.rdoc
 - CHANGELOG
 - MIT-LICENSE
+- README.rdoc
 files:
 - CHANGELOG
 - MIT-LICENSE
 - README.rdoc
 - lib/minitest/parallel_fork.rb
 - lib/minitest/parallel_fork/fail_fast.rb
+- lib/minitest/parallel_fork/halt.rb
+- lib/minitest/parallel_fork/interrupt.rb
 homepage: http://github.com/jeremyevans/minitest-parallel_fork
 licenses:
 - MIT
@@ -80,7 +81,6 @@ metadata:
   changelog_uri: https://github.com/jeremyevans/minitest-parallel_fork/blob/master/CHANGELOG
   mailing_list_uri: https://github.com/jeremyevans/minitest-parallel_fork/discussions
   source_code_uri: https://github.com/jeremyevans/minitest-parallel_fork
-post_install_message:
 rdoc_options:
 - "--quiet"
 - "--line-numbers"
@@ -102,8 +102,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Fork-based parallelization for minitest
 test_files: []