forking_test_runner 1.2.0 → 1.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 20b5dbbcbf7a0eccd84759792ee55fc23df3f532
-  data.tar.gz: 60bb004e09edc70351417d004c48a744c4ffae5c
+SHA256:
+  metadata.gz: 6d802108391cd0edbb4c9a9628ca56d447dbc07992f07cf8c1ffc1e61d770d5a
+  data.tar.gz: cabbf4e263465b03e1bc47435b15ce5186c3478f409095f57d2197e49ca5e0e5
 SHA512:
-  metadata.gz: 9805ac39da7d1a475e56c7b3054534d3258509e11d1938c1c2b3a788a822221cd5339124f80348bf0700ddfb7ef809e69d6d6a8995531227ead0185d245b5210
-  data.tar.gz: 3e7e2728ed1603e89765e112bd275480364051b88ef080ba5bb45a89958fa7aed1ce90bc491ffead1a1b0c67d3a4230e5faa43e8774ca073138bc5d2002256a9
+  metadata.gz: 921396a5eec38e183f71ab4ba42340dad7c34f81d622af12ad9df156c639ce0c41d53ba0bcaff9c3e5efa6e52d5416a1676a018f6cacb1e4aa01fb820d338781
+  data.tar.gz: c79fcf65d60af55227c194baf05c86275a1d6d2b1132fa14bd311480d982b490b40d991c02f8a14ad9a95f7578fbd92ee1b6f7a7e32108dc9a853c4d92594f90

data/lib/forking_test_runner/cli.rb

@@ -0,0 +1,94 @@
+module ForkingTestRunner
+  # read and delete options we support and pass the rest through to the underlying test runner (-v / --seed etc)
+  module CLI
+    OPTIONS = [
+      [:rspec, "--rspec", "RSpec mode"],
+      [:helper, "--helper", "Helper file to load before tests start", String],
+      [:quiet, "--quiet", "Quiet"],
+      [:no_fixtures, "--no-fixtures", "Do not load fixtures"],
+      [:no_ar, "--no-ar", "Disable ActiveRecord logic"],
+      [:merge_coverage, "--merge-coverage", "Merge base code coverage into individual files coverage and summarize coverage report"],
+      [
+        :record_runtime,
+        "--record-runtime=MODE",
+        "\n      Record test runtime:\n" <<
+          "        simple = write to disk at --runtime-log)\n" <<
+          "        amend  = write from multiple remote workers via http://github.com/grosser/amend, needs TRAVIS_REPO_SLUG & TRAVIS_BUILD_NUMBER",
+        String
+      ],
+      [:runtime_log, "--runtime-log=FILE", "File to store runtime log in or runtime.log", String],
+      [:parallel, "--parallel=NUM", "Number of parallel groups to run at once", Integer],
+      [:group, "--group=NUM[,NUM]", "What group this is (use with --groups / starts at 1)", String],
+      [:groups, "--groups=NUM", "How many groups there are in total (use with --group)", Integer],
+      [:version, "--version", "Show version"],
+      [:help, "--help", "Show help"]
+    ]
+
+    class << self
+      def parse_options(argv)
+        options = OPTIONS.each_with_object({}) do |(setting, flag, _, type), all|
+          all[setting] = delete_argv(flag.split('=', 2)[0], argv, type: type)
+        end
+
+        # show version
+        if options.fetch(:version)
+          puts VERSION
+          exit 0
+        end
+
+        # show help
+        if options[:help]
+          puts help
+          exit 0
+        end
+
+        # check if we can use merge_coverage
+        if options.fetch(:merge_coverage)
+          abort "merge_coverage does not work on ruby prior to 2.3" if RUBY_VERSION < "2.3.0"
+        end
+
+        if !!options.fetch(:group) ^ !!options.fetch(:groups)
+          abort "use --group and --groups together"
+        end
+
+        # all remaining non-flag options until the next flag must be tests
+        next_flag = argv.index { |arg| arg.start_with?("-") } || argv.size
+        tests = argv.slice!(0, next_flag)
+        abort "No tests or folders found in arguments" if tests.empty?
+        tests.each { |t| abort "Unable to find #{t}" unless File.exist?(t) }
+
+        [options, tests]
+      end
+
+      private
+
+      # fake parser that will print nicely
+      def help
+        OptionParser.new("forking-test-runner folder [options]", 32, '') do |opts|
+          OPTIONS.each do |_, flag, desc, type|
+            opts.on(flag, desc, type)
+          end
+        end
+      end
+
+      # we remove the args we understand and leave the rest alone
+      # so minitest / rspec can read their own options (--seed / -v ...)
+      #  - keep our options clear / unambiguous to avoid overriding
+      #  - read all serial non-flag arguments as tests and leave only unknown options behind
+      #  - use .fetch everywhere to make sure nothing is misspelled
+      # GOOD: test --ours --theirs
+      # OK: --ours test --theirs
+      # BAD: --theirs test --ours
+      def delete_argv(name, argv, type: nil)
+        return unless index = argv.index(name)
+        argv.delete_at(index)
+        if type
+          found = argv.delete_at(index) || raise("Missing argument for #{name}")
+          send(type.name, found) # case found
+        else
+          true
+        end
+      end
+    end
+  end
+end

data/lib/forking_test_runner/coverage_capture.rb

@@ -0,0 +1,71 @@
+module ForkingTestRunner
+  module CoverageCapture
+    # override Coverage.result to add pre-fork captured coverage
+    def result
+      return super unless captured = CoverageCapture.coverage
+      CoverageCapture.merge_coverage(super, captured)
+    end
+
+    # deprecated, single_cov checks for this, so leave it here
+    def capture_coverage!
+    end
+
+    class << self
+      attr_accessor :coverage
+
+      def activate!
+        require 'coverage'
+        (class << Coverage; self; end).prepend self
+      end
+
+      def capture!
+        self.coverage = Coverage.peek_result.dup
+      end
+
+      def merge_coverage(a, b)
+        merged = a.dup
+        b.each do |file, coverage|
+          orig = merged[file]
+          merged[file] = if orig
+            if coverage.is_a?(Array)
+              merge_lines_coverage(orig, coverage)
+            else
+              {
+                lines: merge_lines_coverage(orig.fetch(:lines), coverage.fetch(:lines)),
+                branches: merge_branches_coverage(orig.fetch(:branches), coverage.fetch(:branches))
+              }
+            end
+          else
+            coverage
+          end
+        end
+        merged
+      end
+
+      private
+
+      # assuming b has same or more keys since it comes from a fork
+      # [nil,1,0] + [nil,nil,2] -> [nil,1,2]
+      def merge_lines_coverage(a, b)
+        b.each_with_index.map do |b_count, i|
+          a_count = a[i]
+          (a_count.nil? && b_count.nil?) ? nil : a_count.to_i + b_count.to_i
+        end
+      end
+
+      # assuming b has same or more keys since it comes from a fork
+      # {foo: {bar: 0, baz: 1}} + {foo: {bar: 1, baz: 0}} -> {foo: {bar: 1, baz: 1}}
+      def merge_branches_coverage(a, b)
+        b.each_with_object({}) do |(branch, v), all|
+          vb = v.dup
+          if part = a[branch]
+            part.each do |nested, a_count|
+              vb[nested] = a_count + vb[nested].to_i
+            end
+          end
+          all[branch] = vb
+        end
+      end
+    end
+  end
+end

data/lib/forking_test_runner/version.rb

@@ -1,3 +1,3 @@
 module ForkingTestRunner
-  VERSION = "1.2.0"
+  VERSION = "1.13.0"
 end

data/lib/forking_test_runner.rb

@@ -1,129 +1,82 @@
 require 'benchmark'
 require 'optparse'
+require 'forking_test_runner/version'
+require 'forking_test_runner/coverage_capture'
+require 'forking_test_runner/cli'
+require 'parallel'
+require 'tempfile'
 
 module ForkingTestRunner
   CLEAR = "------"
-
-  module CoverageCapture
-    def capture_coverage!
-      @capture_coverage = peek_result.dup
-    end
-
-    # override to add pre-fork captured coverage when someone asks for the results
-    def result
-      original = super
-      return original unless @capture_coverage
-      CoverageCapture.merge_coverage(original, @capture_coverage)
-    end
-
-    class << self
-      def merge_coverage(a, b)
-        merged = a.dup
-        b.each do |file, coverage|
-          orig = merged[file]
-          merged[file] = if orig
-            if coverage.is_a?(Array)
-              merge_lines_coverage(orig, coverage)
-            else
-              {
-                lines: merge_lines_coverage(orig.fetch(:lines), coverage.fetch(:lines)),
-                branches: merge_branches_coverage(orig.fetch(:branches), coverage.fetch(:branches))
-              }
-            end
-          else
-            coverage
-          end
-        end
-        merged
-      end
-
-      private
-
-      # assuming b has same or more keys since it comes from a fork
-      # [nil,1,0] + [nil,nil,2] -> [nil,1,2]
-      def merge_lines_coverage(a, b)
-        b.each_with_index.map do |b_count, i|
-          a_count = a[i]
-          (a_count.nil? && b_count.nil?) ? nil : a_count.to_i + b_count.to_i
-        end
-      end
-
-      # assuming b has same or more keys since it comes from a fork
-      # {foo: {bar: 0, baz: 1}} + {foo: {bar: 1, baz: 0}} -> {foo: {bar: 1, baz: 1}}
-      def merge_branches_coverage(a, b)
-        b.each_with_object({}) do |(branch, v), all|
-          vb = v.dup
-          if part = a[branch]
-            part.each do |nested, a_count|
-              vb[nested] = a_count + vb[nested].to_i
-            end
-          end
-          all[branch] = vb
-        end
-      end
-    end
-  end
+  CONVERAGE_REPORT_PREFIX = "coverage/fork-"
 
   class << self
-    def cli(argv)
-      @options, tests = parse_options(argv)
 
-      disable_test_autorun
+    attr_accessor :before_fork_callbacks, :after_fork_callbacks
 
-      load_test_env(@options.fetch(:helper))
+    def cli(argv)
+      @options, tests = CLI.parse_options(argv)
 
       # figure out what we need to run
       runtime_log = @options.fetch(:runtime_log)
-      group, group_count = find_group_args
-      tests = find_tests_for_group(group, group_count, tests, runtime_log)
+      groups, group_count = find_group_args
+      parallel = @options.fetch(:parallel)
+      test_groups =
+        if parallel && !@options.fetch(:group)
+          Array.new(parallel) { |i| find_tests_for_group(i + 1, parallel, tests, runtime_log) }
+        else
+          raise ArgumentError, "Use the same amount of processors as groups" if parallel && parallel != groups.count
+          groups.map { |group| find_tests_for_group(group, group_count, tests, runtime_log) }
+        end
 
+      # say what we are running
+      all_tests = test_groups.flatten(1)
       if @options.fetch(:quiet)
-        puts "Running #{tests.size} test files"
+        puts "Running #{all_tests.size} test files"
       else
-        puts "Running tests #{tests.map(&:first).join(" ")}"
+        puts "Running tests #{all_tests.map(&:first).join(" ")}"
       end
 
-      if ar?
-        preload_fixtures
-        ActiveRecord::Base.connection.disconnect!
-      end
-
-      Coverage.capture_coverage! if @options.fetch(:merge_coverage)
+      @before_fork_callbacks = []
+      @after_fork_callbacks = []
 
       # run all the tests
-      results = tests.map do |file, expected|
-        puts "#{CLEAR} >>> #{file} "
-        time, success, output = benchmark { run_test(file) }
-
-        puts output if !success && @options.fetch(:quiet)
-
-        if runtime_log && !@options.fetch(:quiet)
-          puts "Time: expected #{expected.round(2)}, actual #{time.round(2)}"
-        end
+      results = with_lock do |lock|
+        Parallel.map_with_index(test_groups, in_processes: parallel || 0) do |tests, env_index|
+          if parallel
+            ENV["TEST_ENV_NUMBER"] = (env_index == 0 ? '' : (env_index + 1).to_s) # NOTE: does not support first_is_1 option
+          end
 
-        if !success || !@options.fetch(:quiet)
-          puts "#{CLEAR} <<< #{file} ---- #{success ? "OK" : "Failed"}"
-        end
+          reraise_clean_ar_error { load_test_env }
 
-        [file, time, expected, output, success]
+          tests.map do |file, expected|
+            print_started file unless parallel
+            result = [file, expected, *benchmark { run_test(file) }]
+            sync_stdout lock do
+              print_started file if parallel
+              print_finished *result
+            end
+            result
+          end
+        end.flatten(1)
       end
 
       unless @options.fetch(:quiet)
         # pretty print the results
         puts "\nResults:"
         puts results.
-          sort_by { |_,_,_,_,r| r ? 0 : 1 }. # failures should be last so they are easy to find
-          map { |f,_,_,_,r| "#{f}: #{r ? "OK" : "Fail"}"}
+          sort_by { |_,_,_,r,_| r ? 0 : 1 }. # failures should be last so they are easy to find
+          map { |f,_,_,r,_| "#{f}: #{r ? "OK" : "Fail"}"}
         puts
       end
 
-      success = results.map(&:last).all?
+      success = results.map { |r| r[3] }.all?
 
-      puts colorize(success, summarize_results(results.map { |r| r[3] }))
+      puts colorize(success, summarize_results(results.map { |r| r[4] }))
 
       if runtime_log
         # show how long they ran vs expected
-        diff = results.map { |_,time,expected| time - expected }.inject(:+).to_f
+        diff = results.map { |_, expected, time| time - expected }.inject(:+).to_f
         puts "Time: #{diff.round(2)} diff to expected"
       end
 
@@ -133,12 +86,46 @@ module ForkingTestRunner
         record_test_runtime(mode, results, log)
       end
 
+      summarize_partial_reports if partial_reports_for_single_cov?
+
       # exit with success or failure
       success ? 0 : 1
     end
 
     private
 
+    def with_lock(&block)
+      return yield unless @options.fetch(:parallel)
+      Tempfile.open"forking-test-runner-lock", &block
+    end
+
+    def sync_stdout(lock)
+      return yield unless @options.fetch(:parallel)
+      begin
+        lock.flock(File::LOCK_EX)
+        yield
+      ensure
+        lock.flock(File::LOCK_UN)
+      end
+    end
+
+    def print_started(file)
+      puts "#{CLEAR} >>> #{file}"
+    end
+
+    def print_finished(file, expected, time, success, stdout)
+      # print stdout if it was not shown before, but needs to be shown
+      puts stdout if (!success && @options.fetch(:quiet)) || (@options.fetch(:parallel) && !@options.fetch(:quiet))
+
+      if @options.fetch(:runtime_log) && !@options.fetch(:quiet)
+        puts "Time: expected #{expected.round(2)}, actual #{time.round(2)}"
+      end
+
+      if !success || !@options.fetch(:quiet)
+        puts "#{CLEAR} <<< #{file} ---- #{success ? "OK" : "Failed"}"
+      end
+    end
+
     def colorize(green, string)
       if $stdout.tty?
         "\e[#{green ? 32 : 31}m#{string}\e[0m"
@@ -161,22 +148,25 @@ module ForkingTestRunner
 
     def benchmark
       result = false
-      time = Benchmark.realtime do
-        result = yield
-      end
-      return [time, result].flatten
+      time = Benchmark.realtime { result = yield }
+      [time, *result]
     end
 
     # log runtime via dumping or curling it into the runtime log location
     def record_test_runtime(mode, results, log)
-      data = results.map { |test, time| "#{test}:#{time.round(2)}" }.join("\n") << "\n"
+      data = results.map { |test, _, time| "#{test}:#{time.round(2)}" }.join("\n") << "\n"
 
       case mode
       when 'simple'
         File.write(log, data)
       when 'amend'
-        slug = ENV.fetch("TRAVIS_REPO_SLUG").sub("/", "-")
-        id = ENV.fetch("TRAVIS_BUILD_NUMBER")
+        if id = ENV["BUILDKITE_JOB_ID"]
+          slug = ENV.fetch("BUILDKITE_ORG_SLUG") + "-" + ENV.fetch("BUILDKITE_PIPELINE_SLUG")
+        else
+          slug = ENV.fetch("TRAVIS_REPO_SLUG").sub("/", "-")
+          id = ENV.fetch("TRAVIS_BUILD_NUMBER")
+        end
+
         url = "https://amend.herokuapp.com/amend/#{slug}-#{id}"
 
         require 'tempfile'
@@ -192,21 +182,48 @@ module ForkingTestRunner
     end
 
     def find_group_args
-      if @options.fetch(:group) && @options.fetch(:groups)
+      group = @options.fetch(:group)
+      groups = @options.fetch(:groups)
+      if group && groups
         # delete options we want while leaving others as they are (-v / --seed etc)
-        group = @options.fetch(:group)
-        group_count = @options.fetch(:groups)
+        [group.split(",").map { |g| Integer(g) }, groups]
       else
-        group = 1
-        group_count = 1
+        [[1], 1]
+      end
+    end
+
+    def load_test_env
+      CoverageCapture.activate! if @options.fetch(:merge_coverage)
+
+      load_test_helper
+
+      if active_record?
+        preload_fixtures
+        ActiveRecord::Base.connection.disconnect!
+      end
+      @before_fork_callbacks.each(&:call)
+
+      CoverageCapture.capture! if @options.fetch(:merge_coverage)
+    end
+
+    def reraise_clean_ar_error
+      return yield unless @options.fetch(:parallel)
+
+      e = begin
+        yield
+        nil
+      rescue
+        $!
       end
 
-      [group, group_count]
+      # needs to be done outside of the rescue block to avoid inheriting the cause
+      raise RuntimeError, "Re-raised error from test helper: #{e.message}", e.backtrace if e
     end
 
-    def load_test_env(helper=nil)
+    def load_test_helper
+      disable_test_autorun
       require 'rspec/core' if @options.fetch(:rspec)
-      helper = helper || (@options.fetch(:rspec) ? "spec/spec_helper" : "test/test_helper")
+      helper =  @options.fetch(:helper) || (@options.fetch(:rspec) ? "spec/spec_helper" : "test/test_helper")
       require "./#{helper}"
     end
 
@@ -215,9 +232,8 @@ module ForkingTestRunner
     def preload_fixtures
       return if @options.fetch(:no_fixtures)
 
-      fixtures = (ActiveSupport::VERSION::MAJOR == 3 ? ActiveRecord::Fixtures : ActiveRecord::FixtureSet)
-
       # reuse our pre-loaded fixtures even if we have a different connection
+      fixtures = ActiveRecord::FixtureSet
       fixtures_eigenclass = class << fixtures; self; end
       fixtures_eigenclass.send(:define_method, :cache_for_connection) do |_connection|
         fixtures.class_variable_get(:@@all_cached_fixtures)[:unique]
@@ -241,13 +257,12 @@ module ForkingTestRunner
       toggle_test_autorun true, file
     end
 
-    def fork_with_captured_output(tee_to_stdout)
+    def fork_with_captured_stdout
       rpipe, wpipe = IO.pipe
 
-      child = fork do
+      child = Process.fork do
         rpipe.close
-        $stdout.reopen(wpipe)
-
+        preserve_tty { $stdout.reopen(wpipe) }
         yield
       end
 
@@ -257,18 +272,34 @@ module ForkingTestRunner
 
       while ch = rpipe.read(1)
         buffer << ch
-        $stdout.write(ch) if tee_to_stdout
+        $stdout.write(ch) if !@options.fetch(:quiet) && !@options.fetch(:parallel) # tee
       end
 
       Process.wait(child)
       buffer
     end
 
+    # not tested via CI
+    def preserve_tty
+      was_tty = $stdout.tty?
+      yield
+      def $stdout.tty?; true; end if was_tty
+    end
+
     def run_test(file)
-      output = change_program_name_to file do
-        fork_with_captured_output(!@options.fetch(:quiet)) do
-          SimpleCov.pid = Process.pid if defined?(SimpleCov) && SimpleCov.respond_to?(:pid=) # trick simplecov into reporting in this fork
-          if ar?
+      stdout = change_program_name_to file do
+        fork_with_captured_stdout do
+          if defined?(SimpleCov)
+            SimpleCov.pid = Process.pid
+            SimpleCov.command_name file
+          end
+          if partial_reports_for_single_cov?
+            SingleCov.coverage_report = "#{CONVERAGE_REPORT_PREFIX}#{Process.pid}.json"
+          end
+
+          @after_fork_callbacks.each(&:call)
+
+          if active_record?
             key = (ActiveRecord::VERSION::STRING >= "4.1.0" ? :test : "test")
             ActiveRecord::Base.establish_connection key
           end
@@ -276,14 +307,21 @@ module ForkingTestRunner
         end
       end
 
-      [$?.success?, output]
+      [$?.success?, stdout]
+    end
+
+    def partial_reports_for_single_cov?
+      @options.fetch(:merge_coverage) && defined?(SingleCov) && SingleCov.respond_to?(:coverage_report=) && SingleCov.coverage_report
     end
 
     def change_program_name_to(name)
-      old, $0 = $0, name
-      yield
-    ensure
-      $0 = old
+      return yield if @options.fetch(:parallel)
+      begin
+        old, $0 = $0, name
+        yield
+      ensure
+        $0 = old
+      end
     end
 
     def find_tests_for_group(group, group_count, tests, runtime_log)
@@ -304,21 +342,15 @@ module ForkingTestRunner
       group.map { |test| [test, (tests[test] if group_by == :runtime)] }
     end
 
-    def ar?
-      defined?(ActiveRecord::Base)
+    def active_record?
+      !@options.fetch(:no_ar) && defined?(ActiveRecord::Base)
     end
 
     def minitest_class
       @minitest_class ||= begin
         require 'bundler/setup'
-        gem 'minitest'
-        if Gem.loaded_specs["minitest"].version.segments.first == 4 # 4.x
-          require 'minitest/unit'
-          MiniTest::Unit
-        else
-          require 'minitest'
-          Minitest
-        end
+        require 'minitest'
+        Minitest
       end
     end
 
@@ -338,88 +370,32 @@ module ForkingTestRunner
 
         if value
           minitest_class.autorun
-          require(file.start_with?('/') ? file : "./#{file}")
+          load file
         end
       end
     end
 
-    # we remove the args we understand and leave the rest alone
-    # so minitest / rspec can read their own options (--seed / -v ...)
-    #  - keep our options clear / unambiguous to avoid overriding
-    #  - read all serial non-flag arguments as tests and leave only unknown options behind
-    #  - use .fetch everywhere to make sure nothing is misspelled
-    # GOOD: test --ours --theirs
-    # OK: --ours test --theirs
-    # BAD: --theirs test --ours
-    def parse_options(argv)
-      arguments = [
-        [:rspec, "--rspec", "RSpec mode"],
-        [:helper, "--helper", "Helper file to load before tests start", String],
-        [:quiet, "--quiet", "Quiet"],
-        [:no_fixtures, "--no-fixtures", "Do not load fixtures"],
-        [:merge_coverage, "--merge-coverage", "Merge base code coverage into indvidual files coverage, great for SingleCov"],
-        [
-          :record_runtime,
-          "--record-runtime=MODE",
-          "\n      Record test runtime:\n" <<
-          "        simple = write to disk at --runtime-log)\n" <<
-          "        amend  = write from multiple remote workers via http://github.com/grosser/amend, needs TRAVIS_REPO_SLUG & TRAVIS_BUILD_NUMBER",
-          String
-        ],
-        [:runtime_log, "--runtime-log=FILE", "File to store runtime log in or runtime.log", String],
-        [:group, "--group=NUM", "What group this is (use with --groups / starts at 1)", Integer],
-        [:groups, "--groups=NUM", "How many groups there are in total (use with --group)", Integer],
-        [:version, "--version", "Show version"],
-        [:help, "--help", "Show help"]
-      ]
-
-      options = arguments.each_with_object({}) do |(setting, flag, _, type), all|
-        all[setting] = delete_argv(flag.split('=', 2)[0], argv, type: type)
+    def summarize_partial_reports
+      reports = Dir.glob("#{CONVERAGE_REPORT_PREFIX}*")
+      return if reports.empty?
+      key = nil
+
+      require "json" # not a global dependency
+      coverage = reports.each_with_object({}) do |report, all|
+        data = JSON.parse(File.read(report), symbolize_names: true)
+        key ||= data.keys.first
+        suites = data.values
+        raise "Unsupported number of suites #{suites.size}" if suites.size != 1
+        all.replace CoverageCapture.merge_coverage(all, suites.first.fetch(:coverage))
+      ensure
+        File.unlink(report) # do not leave junk behind
       end
 
-      # show version
-      if options.fetch(:version)
-        puts VERSION
-        exit 0
-      end
-
-      # # show help
-      if options[:help]
-        parser = OptionParser.new("forking-test-runner folder [options]", 32, '') do |opts|
-          arguments.each do |_, flag, desc, type|
-            opts.on(flag, desc, type)
-          end
-        end
-        puts parser
-        exit 0
-      end
-
-      # check if we can use merge_coverage
-      if options.fetch(:merge_coverage)
-        abort "merge_coverage does not work on ruby prior to 2.3" if RUBY_VERSION < "2.3.0"
-        require 'coverage'
-        klass = (class << Coverage; self; end)
-        klass.prepend CoverageCapture
-      end
-
-      # all remaining non-flag options until the next flag must be tests
-      next_flag = argv.index { |arg| arg.start_with?("-") } || argv.size
-      tests = argv.slice!(0, next_flag)
-      abort "No tests or folders found in arguments" if tests.empty?
-      tests.each { |t| abort "Unable to find #{t}" unless File.exist?(t) }
-
-      [options, tests]
-    end
+      data = JSON.pretty_generate(key => {"coverage" => coverage, "timestamp" => Time.now.to_i })
+      File.write(SingleCov.coverage_report, data)
 
-    def delete_argv(name, argv, type: nil)
-      return unless index = argv.index(name)
-      argv.delete_at(index)
-      if type
-        found = argv.delete_at(index) || raise("Missing argument for #{name}")
-        send(type.name, found) # case found
-      else
-        true
-      end
+      # make it not override our report when it finishes for main process
+      SingleCov.coverage_report = nil
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: forking_test_runner
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.13.0
 platform: ruby
 authors:
 - Michael Grosser
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-15 00:00:00.000000000 Z
+date: 2021-11-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parallel_tests
@@ -24,20 +24,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.3.7
-- !ruby/object:Gem::Dependency
-  name: wwtd
-  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'
 - !ruby/object:Gem::Dependency
   name: bump
   requirement: !ruby/object:Gem::Requirement
@@ -118,6 +104,8 @@ files:
 - MIT-LICENSE
 - bin/forking-test-runner
 - lib/forking_test_runner.rb
+- lib/forking_test_runner/cli.rb
+- lib/forking_test_runner/coverage_capture.rb
 - lib/forking_test_runner/version.rb
 homepage: https://github.com/grosser/forking_test_runner
 licenses:
@@ -131,15 +119,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.0.0
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.14
+rubygems_version: 3.2.16
 signing_key: 
 specification_version: 4
 summary: Run every test in a fork to avoid pollution and get clean output per test