minitest-parallel_fork 1.3.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bdbf96cdc1b208955148ed3e6ccba3d93542785b6e0c628a9b73acad4bcc0614
-  data.tar.gz: 18a0e8ed8d41d9c2d36d8927939d3b8865264b363df7194fefe1cb8238cecac3
+  metadata.gz: 2698fbcfb5e14bed9fbf23e2abe38c5395b615f4443e335ce606b2f674883e30
+  data.tar.gz: dff7fbdc3104a729405415688ff35e574d65df94ac0c2086f3791e5005a95dfd
 SHA512:
-  metadata.gz: 874cd2b108f8f52135e6ea193dd5bb46b9416247dafab76e135a02456cc456a499c05f140aca081b9bf6f5a7c27affdd553cf752d51d8f7513ff150a1dca2d5d
-  data.tar.gz: ad5e405c811f861ae524a56c9d7e1d9bb397f4421898d5a103dddc646747b1c6dd5f02d20aafc2e0b40397308e4a897fb13611f3d9615c9d25766e309492ec85
+  metadata.gz: 80b75938b994edb1f6cfe17c5b8ad31550ab6081738f178ac3dd3c991a7a61fd1a6730d0e855cec3d1d0f5113dddda6ecec455f310ccf4ebcc74298a763a43ae
+  data.tar.gz: 398db64ae6468875db78f49ba7221f8cb1f789161adf361a2125daee43a85acd194c0afbbeb1faab35290c72bc377b4eba1cd01dbfba9ace41255d6278eb4a5b

data/CHANGELOG

@@ -1,3 +1,11 @@
+=== 2.0.0 (2023-11-08)
+
+* Avoid method redefined warning in verbose warning mode (jeremyevans)
+
+* Add minitest/parallel_fork/fail_fast with support for stopping execution as soon as there is a failure in any child process (jeremyevans, stackmystack) (#12)
+
+* Refactor internals for easier extension (jeremyevans)
+
 === 1.3.1 (2023-09-25)
 
 * Bump required_ruby_version to 2.2, since that is lowest version supported by minitest 5.15.0 (jeremyevans)

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2015,2017 Jeremy Evans
+Copyright (c) 2015-2023 Jeremy Evans
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to

data/README.rdoc

@@ -68,6 +68,17 @@ it reports results.
     # Gather relevant logs for more debugging
   end
 
+== Fail Fast Support
+
+If you would like to run tests in parallel, but stop running tests at the first
+failure, you can use:
+
+  RUBYOPT=-rminitest/parallel_fork/fail_fast rake spec
+
+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.
+
 == ActiveRecord
 
 To use this with Rails/ActiveRecord, you probably want to use hooks similar to:

data/lib/minitest/parallel_fork/fail_fast.rb

@@ -0,0 +1,69 @@
+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
+
+  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.rb

@@ -1,89 +1,132 @@
-gem 'minitest'
 require 'minitest'
 
+module Minitest::Unparallelize
+  define_method(:run_one_method, &Minitest::Test.method(:run_one_method))
+end
+
 module Minitest
+  @before_parallel_fork = nil
+  @after_parallel_fork = nil
+  @on_parallel_fork_marshal_failure = nil
+end
+
+class << Minitest
   # Set the before_parallel_fork block to the given block
-  def self.before_parallel_fork(&block)
+  def before_parallel_fork(&block)
     @before_parallel_fork = block
   end
-  @before_parallel_fork = nil
 
   # Set the after_parallel_fork block to the given block
-  def self.after_parallel_fork(i=nil, &block)
+  def after_parallel_fork(i=nil, &block)
     @after_parallel_fork = block
   end
-  @after_parallel_fork = nil
 
   # Set the on_parallel_fork_marshal_failure block to the given block
-  def self.on_parallel_fork_marshal_failure(&block)
+  def on_parallel_fork_marshal_failure(&block)
     @on_parallel_fork_marshal_failure = block
   end
-  @on_parallel_fork_marshal_failure = nil
 
-  module Unparallelize
-    define_method(:run_one_method, &Minitest::Test.method(:run_one_method))
-  end
-  
-  def self.parallel_fork_stat_reporter(reporter)
-    reporter.reporters.detect do |rep|
+  attr_reader :parallel_fork_stat_reporter
+
+  def set_parallel_fork_stat_reporter(reporter)
+    @parallel_fork_stat_reporter = reporter.reporters.detect do |rep|
       %w'count assertions results count= assertions='.all?{|meth| rep.respond_to?(meth)}
     end
   end
 
-  # Override __run to use a child forks to run the speeds, which
-  # allows for parallel spec execution on MRI.
-  def self.__run(reporter, options)
-    suites = Runnable.runnables.shuffle
-    stat_reporter = parallel_fork_stat_reporter(reporter)
+  def parallel_fork_suites
+    Minitest::Runnable.runnables.shuffle
+  end
 
-    n = (ENV['NCPU'] || 4).to_i
-    reads = []
+  def run_before_parallel_fork_hook
     if @before_parallel_fork
       @before_parallel_fork.call
     end
-    n.times do |i|
+  end
+
+  def run_after_parallel_fork_hook(i)
+    if @after_parallel_fork
+      @after_parallel_fork.call(i)
+    end
+  end
+
+  def parallel_fork_data_to_marshal
+    %i'count assertions results'.map{|meth| parallel_fork_stat_reporter.send(meth)}
+  end
+
+  def parallel_fork_data_from_marshal(data)
+    Marshal.load(data)
+  rescue ArgumentError
+    if @on_parallel_fork_marshal_failure
+      @on_parallel_fork_marshal_failure.call
+    end
+    raise
+  end
+
+  def parallel_fork_run_test_suites(suites, reporter, options)
+    suites.each do |suite|
+      parallel_fork_run_test_suite(suite, reporter, options)
+    end
+  end
+
+  def parallel_fork_run_test_suite(suite, reporter, options)
+    if suite.is_a?(Minitest::Parallel::Test::ClassMethods)
+      suite.extend(Minitest::Unparallelize)
+    end
+
+    suite.run(reporter, options)
+  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}
-      reads << read
-      Process.fork do
+      pid = Process.fork do
         read.close
-        if @after_parallel_fork
-          @after_parallel_fork.call(i)
-        end
+        run_after_parallel_fork_hook(i)
 
         p_suites = []
         suites.each_with_index{|s, j| p_suites << s if j % n == i}
-        p_suites.each do |s|
-          if s.is_a?(Minitest::Parallel::Test::ClassMethods)
-            s.extend(Unparallelize)
-          end
+        parallel_fork_run_test_suites(p_suites, reporter, options)
 
-          s.run(reporter, options)
-        end
-
-        data = %w'count assertions results'.map{|meth| stat_reporter.send(meth)}
-        write.write(Marshal.dump(data))
+        write.write(Marshal.dump(parallel_fork_data_to_marshal))
         write.close
       end
       write.close
+      [pid, read]
     end
+  end
 
-    reads.map{|read| Thread.new(read, &:read)}.map(&:value).each do |data|
-      begin
-        count, assertions, results = Marshal.load(data)
-      rescue ArgumentError
-        if @on_parallel_fork_marshal_failure
-          @on_parallel_fork_marshal_failure.call
-        end
-        raise
-      end
+  def parallel_fork_child_data(data)
+    data.map{|_pid, read| Thread.new(read, &:read)}.map(&:value).map{|data| parallel_fork_data_from_marshal(data)}
+  end
+
+  def parallel_fork_wait_for_children(child_info, reporter)
+    parallel_fork_child_data(child_info).each do |data|
+      count, assertions, results = data
       reporter.reporters.each do |rep|
-        next unless %w'count assertions results count= assertions='.all?{|meth| rep.respond_to?(meth)}
+        next unless %i'count assertions results count= assertions='.all?{|meth| rep.respond_to?(meth)}
         rep.count += count
         rep.assertions += assertions
         rep.results.concat(results)
       end
     end
+  end
 
+  def parallel_fork_number
+    (ENV['NCPU'] || 4).to_i
+  end
+
+  # Avoid method redefined verbose warning
+  alias __run __run
+
+  # Override __run to use a child forks to run the speeds, which
+  # allows for parallel spec execution on MRI.
+  def __run(reporter, options)
+    parallel_fork_wait_for_children(parallel_fork_setup_children(parallel_fork_suites, reporter, options), reporter)
     nil
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: minitest-parallel_fork
 version: !ruby/object:Gem::Version
-  version: 1.3.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-09-25 00:00:00.000000000 Z
+date: 2023-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -71,6 +71,7 @@ files:
 - MIT-LICENSE
 - README.rdoc
 - lib/minitest/parallel_fork.rb
+- lib/minitest/parallel_fork/fail_fast.rb
 homepage: http://github.com/jeremyevans/minitest-parallel_fork
 licenses:
 - MIT