minitest-parallel_fork 1.0.2 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 42f6c6919472888f0ad2799def6d83c39bf69ab6
-  data.tar.gz: e4fe5385b3e8682001470c2c6891bc8eadb49696
+SHA256:
+  metadata.gz: 9c152ef9216b8cbc9700f7f7e0281847695b325e660b51268b0d148a44e5aba2
+  data.tar.gz: 9d0739abeb8ccfaeb0ed023cb75b4fe30bb3f6e509af6d952204042229356649
 SHA512:
-  metadata.gz: 007440c55981f82d53333b49efc3ca47609eed8ad9e7601fb215b125cabe4b8d809181a97b4f467e3f87a97373907dc169401de53f8b547711c9408f67842536
-  data.tar.gz: 80d30b6fde62eaec6ca63ab203890a19a564243677b7bc9fa5ca01ac56a741c95f79b3dfb484d6b8abb52c2a64b35e7b1a2bb6e546a2dba94bf3ff0a434e8f2b
+  metadata.gz: e075bac95ab8dd13987e59533ace22ff48d878db63399659764f7af6c553cf835282b39044b50592ec776ab5ebc2d1af095bc9d8df955c0b230cce3cfe58a2e3
+  data.tar.gz: 57448ca69342f474102377fb287c67d298db98147bef22450d721cdae0acc4e9f65aad7d3e3937fc834118fd10e6200ced55d04609bc7ac43527dc1d6b63f5c7

data/CHANGELOG

@@ -1,3 +1,25 @@
+=== 1.2.0 (2021-08-16)
+
+* Work correctly with Minitest 5.14+ (jeremyevans)
+
+* Add on_parallel_fork_marshal_failure hook for handling marshal failures (child process exiting) (jeremyevans)
+
+=== 1.1.2 (2018-07-05)
+
+* Handle raised exceptions containing unmarshallable data (jeremyevans)
+
+=== 1.1.1 (2018-05-07)
+
+* Work around marshalling issue when there are failures in *_all hooks when using minitest-hooks (jeremyevans)
+
+* Don't deadlock when a child process sends a large amount of marshalled data (chanks) (#4, #5)
+
+=== 1.1.0 (2018-04-19)
+
+* Remove DumpableUnexpectedError, require minitest 5.11.0+ (jeremyevans)
+
+* Allow overriding the stat reporter used via Minitest.parallel_fork_stat_reporter method (jeremyevans) (#3)
+
 === 1.0.2 (2017-02-27)
 
 * Show correct number of errors in output (jeremyevans)

data/README.rdoc

@@ -1,7 +1,7 @@
 = minitest-parallel_fork
 
 minitest-parallel_fork adds fork-based parallelization to Minitest.  Each test/spec
-suite is run one of the forks, allowing this to work correctly when using
+suite is run in one of the forks, allowing this to work correctly when using
 before_all/after_all/around_all hooks provided by minitest-hooks.  Using separate
 processes via fork can significantly improve spec performance when using MRI,
 and can work in cases where Minitest's default thread-based parallelism do not work,
@@ -55,10 +55,19 @@ of the child process, starting at 0:
 
 The above examples show a fairly easy way to use minitest-parallel_fork with an external
 database when using Sequel.  Before forking, all existing database connections are
-disconnecting, and after forking, the database name is changed in each child to reference
+disconnected, and after forking, the database name is changed in each child to reference
 a child-specific database, so that the child processes do not share a database and are
 thus independent.
 
+There is also a hook for debugging.  +on_parallel_fork_marshal_failure+ is called if
+there is an error unmarshalling data sent from the child process to the parent process.
+This can happen if one of the child processes exits unexpected during the test, before
+it reports results.
+
+  Minitest.on_parallel_fork_marshal_failure do
+    # Gather relevant logs for more debugging
+  end
+
 == ActiveRecord
 
 To use this with Rails/ActiveRecord, you probably want to use hooks similar to:

data/Rakefile

@@ -13,7 +13,6 @@ end
 desc "Run specs"
 task :spec do
   ENV['RUBY'] = FileUtils::RUBY
-  ENV['RUBYOPT'] = "#{ENV['RUBYOPT']} -rubygems"
   sh %{#{FileUtils::RUBY} spec/minitest_parallel_fork_spec.rb}
 end
 

data/lib/minitest/parallel_fork.rb

@@ -6,49 +6,37 @@ module Minitest
   def self.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)
     @after_parallel_fork = block
   end
+  @after_parallel_fork = nil
 
-  # Subclass of Assertion for unexpected errors.  UnexpectedError
-  # can not be used as it can include undumpable objects.  This
-  # class converts all data it needs to plain strings, so that
-  # it will be dumpable.
-  class DumpableUnexpectedError < Assertion # :nodoc:
-    attr_accessor :backtrace
-
-    def initialize(unexpected)
-      exception_class_name = unexpected.exception.class.name.to_s
-      exception_message = unexpected.exception.message.to_s
-      super("#{exception_class_name}: #{exception_message}")
-      self.backtrace = unexpected.exception.backtrace.map(&:to_s)
-    end
-
-    def message
-      bt = Minitest.filter_backtrace(backtrace).join "\n    "
-      "#{super}\n    #{bt}"
-    end
-
-    def result_label
-      "Error"
-    end
+  # Set the on_parallel_fork_marshal_failure block to the given block
+  def self.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{|rep| rep.is_a?(StatisticsReporter)}
+  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 = reporter.reporters.detect{|rep| rep.is_a?(StatisticsReporter)}
+    stat_reporter = parallel_fork_stat_reporter(reporter)
 
     n = (ENV['NCPU'] || 4).to_i
     reads = []
-    if defined?(@before_parallel_fork)
+    if @before_parallel_fork
       @before_parallel_fork.call
     end
     n.times do |i|
@@ -56,7 +44,7 @@ module Minitest
       reads << read
       fork do
         read.close
-        if defined?(@after_parallel_fork)
+        if @after_parallel_fork
           @after_parallel_fork.call(i)
         end
 
@@ -71,8 +59,29 @@ module Minitest
         end
 
         data = %w'count assertions results'.map{|meth| stat_reporter.send(meth)}
-        data[-1] = data[-1].map do |res|
-          [res.name, res.failures.map{|f| f.is_a?(UnexpectedError) ? DumpableUnexpectedError.new(f) : f}]
+        if data[-1].any?{|result| !result.is_a?(Minitest::Result)}
+          data[-1] = data[-1].map do |result|
+            Minitest::Result.from(result)
+          end
+        end
+
+        data[-1].each do |result|
+          result.failures.each do |failure|
+            if failure.is_a?(Minitest::UnexpectedError)
+              e = failure.respond_to?(:error) ? failure.error : failure.exception
+              begin
+                Marshal.dump(e)
+              rescue TypeError
+                e2 = RuntimeError.new("Wrapped undumpable exception for: #{e.class}: #{e.message}")
+                e2.set_backtrace(e.backtrace)
+                if failure.respond_to?(:error=)
+                  failure.error = e2
+                else
+                  failure.exception = e2
+                end
+              end
+            end
+          end
         end
 
         write.write(Marshal.dump(data))
@@ -80,23 +89,20 @@ module Minitest
       end
       write.close
     end
-    Process.waitall
 
-    Thread.new do
-      reads.each do |r|
-        data = r.read
-        r.close
+    reads.map{|read| Thread.new(read, &:read)}.map(&:value).each do |data|
+      begin
         count, assertions, results = Marshal.load(data)
-        stat_reporter.count += count
-        stat_reporter.assertions += assertions
-        results.map! do |name, failures|
-          runnable = Test.new(name)
-          runnable.failures.concat(failures.map{|f| f.is_a?(DumpableUnexpectedError) ? UnexpectedError.new(f) : f})
-          runnable
+      rescue ArgumentError
+        if @on_parallel_fork_marshal_failure
+          @on_parallel_fork_marshal_failure.call
         end
-        stat_reporter.results.concat(results)
+        raise
       end
-    end.join
+      stat_reporter.count += count
+      stat_reporter.assertions += assertions
+      stat_reporter.results.concat(results)
+    end
 
     nil
   end

data/spec/minitest_parallel_fork_example.rb

@@ -1,5 +1,5 @@
 gem 'minitest'
-require 'minitest/autorun'
+require 'minitest/global_expectations/autorun'
 require 'minitest/parallel_fork'
 
 a = nil
@@ -12,6 +12,16 @@ Minitest.after_parallel_fork do |i|
   print ":child#{i}#{a}"
 end
 
+if ENV['MPF_TEST_CHILD_FAILURE']
+  Minitest.on_parallel_fork_marshal_failure do |i|
+    print ":child-failure#{i}#{a}"
+  end
+end
+
+class MyExceptionClass < StandardError
+  attr_reader :something
+end
+
 4.times do |i|
   describe 'minitest/parallel_fork' do
     parallelize_me! if ENV['MPF_PARALLELIZE_ME']
@@ -23,7 +33,8 @@ end
     end
 
     it "should work" do
-      sleep(1).must_equal 1
+      sleep(1)
+      1.must_equal 1
     end
 
     it "should fail" do
@@ -31,9 +42,16 @@ end
     end
 
     it "should raise" do
+      exit(1) if ENV['MPF_TEST_CHILD_FAILURE']
       raise
     end
 
+    it "should raise exception containing undumpable data" do
+      e = MyExceptionClass.new("error")
+      e.something = Class.new
+      raise e
+    end
+
     it "should skip" do
       skip
     end

data/spec/minitest_parallel_fork_spec.rb

@@ -1,5 +1,6 @@
+ENV['MT_NO_PLUGINS'] = '1'
 gem 'minitest'
-require 'minitest/autorun'
+require 'minitest/global_expectations/autorun'
 
 describe 'minitest/parallel_fork' do
   [[nil, ''],
@@ -17,10 +18,23 @@ describe 'minitest/parallel_fork' do
       time.must_be :<, 4
       time.must_be :>, 1
       output.must_match /:parent/
-      output.must_match /16 runs, 8 assertions, 4 failures, 4 errors, 4 skips/
+      output.must_match /20 runs, 8 assertions, 4 failures, 8 errors, 4 skips/
       4.times do |i|
         output.must_match /:child#{i}a/
       end
     end
   end
+
+  it "should call on_parallel_fork_marshal_failure on failure" do
+    t = Time.now
+    ENV['NCPU'] = '4'
+    ENV['MPF_TEST_CHILD_FAILURE'] = '1'
+    output = `#{ENV['RUBY']} -I lib spec/minitest_parallel_fork_example.rb 2>&1`
+    ENV.delete('MPF_TEST_CHILD_FAILURE')
+
+    time = (Time.now - t)
+    time.must_be :<, 4
+    output.must_match /:child-failurea/
+    output.must_match /marshal data too short/
+  end
 end

metadata

@@ -1,32 +1,46 @@
 --- !ruby/object:Gem::Specification
 name: minitest-parallel_fork
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.2.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-27 00:00:00.000000000 Z
+date: 2021-08-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '5'
+        version: 5.11.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '5'
+        version: 5.11.0
+- !ruby/object:Gem::Dependency
+  name: minitest-global_expectations
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: |
   minitest-parallel_fork adds fork-based parallelization to Minitest.  Each test/spec
-  suite is run one of the forks, allowing this to work correctly when using
+  suite is run in one of the forks, allowing this to work correctly when using
   before_all/after_all/around_all hooks provided by minitest-hooks.  Using separate
   processes via fork can significantly improve spec performance when using MRI,
   and can work in cases where Minitest's default thread-based parallelism do not work,
@@ -72,8 +86,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.8
+rubygems_version: 3.2.22
 signing_key: 
 specification_version: 4
 summary: Fork-based parallelization for minitest