parallel_tests 1.3.7 → 3.7.3

data/lib/parallel_tests/test/runner.rb

@@ -1,17 +1,12 @@
+# frozen_string_literal: true
 require 'parallel_tests'
 
 module ParallelTests
   module Test
     class Runner
-      NAME = 'Test'
-
       class << self
         # --- usually overwritten by other runners
 
-        def name
-          NAME
-        end
-
         def runtime_log
           'tmp/parallel_runtime_test.log'
         end
@@ -20,25 +15,29 @@ module ParallelTests
           /_(test|spec).rb$/
         end
 
+        def default_test_folder
+          "test"
+        end
+
         def test_file_name
           "test"
         end
 
         def run_tests(test_files, process_number, num_processes, options)
-          require_list = test_files.map { |file| file.sub(" ", "\\ ") }.join(" ")
+          require_list = test_files.map { |file| file.gsub(" ", "\\ ") }.join(" ")
           cmd = "#{executable} -Itest -e '%w[#{require_list}].each { |f| require %{./\#{f}} }' -- #{options[:test_options]}"
           execute_command(cmd, process_number, num_processes, options)
         end
 
+        # ignores other commands runner noise
         def line_is_result?(line)
-          line.gsub!(/[.F*]/,'')
-          line =~ /\d+ failure/
+          line =~ /\d+ failure(?!:)/
         end
 
         # --- usually used by other runners
 
         # finds all tests and partitions them into groups
-        def tests_in_groups(tests, num_groups, options={})
+        def tests_in_groups(tests, num_groups, options = {})
           tests = tests_with_size(tests, options)
           Grouper.in_even_groups_by_size(tests, num_groups, options)
         end
@@ -52,10 +51,17 @@ module ParallelTests
           when :filesize
             sort_by_filesize(tests)
           when :runtime
-            sort_by_runtime(tests, runtimes(tests, options), options.merge(allowed_missing: 0.5))
+            sort_by_runtime(
+              tests, runtimes(tests, options),
+              options.merge(allowed_missing: (options[:allowed_missing_percent] || 50) / 100.0)
+            )
           when nil
             # use recorded test runtime if we got enough data
-            runtimes = runtimes(tests, options) rescue []
+            runtimes = begin
+              runtimes(tests, options)
+            rescue StandardError
+              []
+            end
             if runtimes.size * 1.5 > tests.size
               puts "Using recorded test runtime"
               sort_by_runtime(tests, runtimes)
@@ -71,49 +77,60 @@ module ParallelTests
 
         def execute_command(cmd, process_number, num_processes, options)
           env = (options[:env] || {}).merge(
-            "TEST_ENV_NUMBER" => test_env_number(process_number),
-            "PARALLEL_TEST_GROUPS" => num_processes
+            "TEST_ENV_NUMBER" => test_env_number(process_number, options).to_s,
+            "PARALLEL_TEST_GROUPS" => num_processes.to_s,
+            "PARALLEL_PID_FILE" => ParallelTests.pid_file_path
           )
           cmd = "nice #{cmd}" if options[:nice]
           cmd = "#{cmd} 2>&1" if options[:combine_stderr]
-          puts cmd if options[:verbose]
 
-          execute_command_and_capture_output(env, cmd, options[:serialize_stdout])
-        end
+          puts cmd if report_process_command?(options) && !options[:serialize_stdout]
 
-        def execute_command_and_capture_output(env, cmd, silence)
-          # make processes descriptive / visible in ps -ef
-          separator = (WINDOWS ? ' & ' : ';')
-          exports = env.map do |k,v|
-            if WINDOWS
-              "(SET \"#{k}=#{v}\")"
-            else
-              "#{k}=#{v};export #{k}"
-            end
-          end.join(separator)
-          cmd = "#{exports}#{separator}#{cmd}"
+          execute_command_and_capture_output(env, cmd, options)
+        end
 
-          output = open("|#{cmd}", "r") { |output| capture_output(output, silence) }
+        def execute_command_and_capture_output(env, cmd, options)
+          pid = nil
+          output = IO.popen(env, cmd) do |io|
+            pid = io.pid
+            ParallelTests.pids.add(pid)
+            capture_output(io, env, options)
+          end
+          ParallelTests.pids.delete(pid) if pid
           exitstatus = $?.exitstatus
+          seed = output[/seed (\d+)/, 1]
+
+          output = [cmd, output].join("\n") if report_process_command?(options) && options[:serialize_stdout]
 
-          {:stdout => output, :exit_status => exitstatus}
+          { stdout: output, exit_status: exitstatus, command: cmd, seed: seed }
         end
 
         def find_results(test_output)
-          test_output.split("\n").map {|line|
-            line.gsub!(/\e\[\d+m/,'')
+          test_output.lines.map do |line|
+            line.chomp!
+            line.gsub!(/\e\[\d+m/, '') # remove color coding
             next unless line_is_result?(line)
             line
-          }.compact
+          end.compact
         end
 
-        def test_env_number(process_number)
-          process_number == 0 ? '' : process_number + 1
+        def test_env_number(process_number, options = {})
+          if process_number == 0 && !options[:first_is_1]
+            ''
+          else
+            process_number + 1
+          end
         end
 
         def summarize_results(results)
           sums = sum_up_results(results)
-          sums.sort.map{|word, number|  "#{number} #{word}#{'s' if number != 1}" }.join(', ')
+          sums.sort.map { |word, number| "#{number} #{word}#{'s' if number != 1}" }.join(', ')
+        end
+
+        # remove old seed and add new seed
+        def command_with_seed(cmd, seed)
+          clean = cmd.sub(/\s--seed\s+\d+\b/, '')
+          "#{clean} --seed #{seed}"
         end
 
         protected
@@ -127,34 +144,37 @@ module ParallelTests
         end
 
         def sum_up_results(results)
-          results = results.join(' ').gsub(/s\b/,'') # combine and singularize results
+          results = results.join(' ').gsub(/s\b/, '') # combine and singularize results
           counts = results.scan(/(\d+) (\w+)/)
-          counts.inject(Hash.new(0)) do |sum, (number, word)|
+          counts.each_with_object(Hash.new(0)) do |(number, word), sum|
             sum[word] += number.to_i
-            sum
           end
         end
 
         # read output of the process and print it in chunks
-        def capture_output(out, silence)
-          result = ""
-          loop do
-            begin
+        def capture_output(out, env, options = {})
+          result = +""
+          begin
+            loop do
               read = out.readpartial(1000000) # read whatever chunk we can get
               if Encoding.default_internal
                 read = read.force_encoding(Encoding.default_internal)
               end
               result << read
-              unless silence
-                $stdout.print read
+              unless options[:serialize_stdout]
+                message = read
+                message = "[TEST GROUP #{env['TEST_ENV_NUMBER']}] #{message}" if options[:prefix_output_with_test_env_number]
+                $stdout.print message
                 $stdout.flush
               end
             end
-          end rescue EOFError
+          rescue EOFError
+            nil
+          end
           result
         end
 
-        def sort_by_runtime(tests, runtimes, options={})
+        def sort_by_runtime(tests, runtimes, options = {})
           allowed_missing = options[:allowed_missing] || 1.0
           allowed_missing = tests.size * allowed_missing
 
@@ -162,26 +182,24 @@ module ParallelTests
           tests.sort!
           tests.map! do |test|
             allowed_missing -= 1 unless time = runtimes[test]
-            raise "Too little runtime info" if allowed_missing < 0
+            if allowed_missing < 0
+              log = options[:runtime_log] || runtime_log
+              raise "Runtime log file '#{log}' does not contain sufficient data to sort #{tests.size} test files, please update or remove it."
+            end
             [test, time]
           end
 
-          if options[:verbose]
-            puts "Runtime found for #{tests.count(&:last)} of #{tests.size} tests"
-          end
+          puts "Runtime found for #{tests.count(&:last)} of #{tests.size} tests" if options[:verbose]
 
-          # fill gaps with average runtime
-          known, unknown = tests.partition(&:last)
-          average = (known.any? ? known.map!(&:last).inject(:+) / known.size : 1)
-          unknown.each { |set| set[1] = average }
+          set_unknown_runtime tests, options
         end
 
         def runtimes(tests, options)
           log = options[:runtime_log] || runtime_log
           lines = File.read(log).split("\n")
           lines.each_with_object({}) do |line, times|
-            test, time = line.split(":", 2)
-            next unless test and time
+            test, _, time = line.rpartition(':')
+            next unless test && time
             times[test] = time.to_f if tests.include?(test)
           end
         end
@@ -192,17 +210,23 @@ module ParallelTests
         end
 
         def find_tests(tests, options = {})
-          (tests || []).map do |file_or_folder|
+          suffix_pattern = options[:suffix] || test_suffix
+          include_pattern = options[:pattern] || //
+          exclude_pattern = options[:exclude_pattern]
+
+          (tests || []).flat_map do |file_or_folder|
             if File.directory?(file_or_folder)
               files = files_in_folder(file_or_folder, options)
-              files.grep(test_suffix).grep(options[:pattern]||//)
+              files = files.grep(suffix_pattern).grep(include_pattern)
+              files -= files.grep(exclude_pattern) if exclude_pattern
+              files
             else
               file_or_folder
             end
-          end.flatten.uniq
+          end.uniq
         end
 
-        def files_in_folder(folder, options={})
+        def files_in_folder(folder, options = {})
           pattern = if options[:symlinks] == false # not nil or true
             "**/*"
           else
@@ -210,7 +234,23 @@ module ParallelTests
             # http://stackoverflow.com/questions/357754/can-i-traverse-symlinked-directories-in-ruby-with-a-glob
             "**{,/*/**}/*"
           end
-          Dir[File.join(folder, pattern)].uniq
+          Dir[File.join(folder, pattern)].uniq.sort
+        end
+
+        private
+
+        # fill gaps with unknown-runtime if given, average otherwise
+        # NOTE: an optimization could be doing runtime by average runtime per file size, but would need file checks
+        def set_unknown_runtime(tests, options)
+          known, unknown = tests.partition(&:last)
+          return if unknown.empty?
+          unknown_runtime = options[:unknown_runtime] ||
+            (known.empty? ? 1 : known.map!(&:last).sum / known.size) # average
+          unknown.each { |set| set[1] = unknown_runtime }
+        end
+
+        def report_process_command?(options)
+          options[:verbose] || options[:verbose_process_command]
         end
       end
     end

data/lib/parallel_tests/test/runtime_logger.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'parallel_tests'
 require 'parallel_tests/test/runner'
 
@@ -18,19 +19,28 @@ module ParallelTests
         end
 
         def unique_log
-          lock do
+          with_locked_log do |logfile|
             separator = "\n"
-            groups = File.read(logfile).split(separator).map { |line| line.split(":") }.group_by(&:first)
+            groups = logfile.read.split(separator).map { |line| line.split(":") }.group_by(&:first)
             lines = groups.map do |file, times|
-              time = "%.2f" % times.map(&:last).map(&:to_f).inject(:+)
+              time = "%.2f" % times.map(&:last).map(&:to_f).sum
               "#{file}:#{time}"
             end
-            File.write(logfile, lines.join(separator) + separator)
+            logfile.rewind
+            logfile.write(lines.join(separator) + separator)
+            logfile.truncate(logfile.pos)
           end
         end
 
         private
 
+        def with_locked_log
+          File.open(logfile, File::RDWR | File::CREAT) do |logfile|
+            logfile.flock(File::LOCK_EX)
+            yield logfile
+          end
+        end
+
         # ensure folder exists + clean out previous log
         # this will happen in multiple processes, but should be roughly at the same time
         # so there should be no log message lost
@@ -43,28 +53,18 @@ module ParallelTests
 
         def log(test, time)
           return unless message = message(test, time)
-          lock do
-            File.open(logfile, 'a') { |f| f.puts message }
+          with_locked_log do |logfile|
+            logfile.seek(0, IO::SEEK_END)
+            logfile.puts message
           end
         end
 
         def message(test, delta)
-          return unless method = test.public_instance_methods(true).detect { |method| method =~ /^test_/ }
+          return unless method = test.public_instance_methods(true).detect { |m| m =~ /^test_/ }
           filename = test.instance_method(method).source_location.first.sub("#{Dir.pwd}/", "")
           "#{filename}:#{delta}"
         end
 
-        def lock
-          File.open(logfile, 'r') do |f|
-            begin
-              f.flock File::LOCK_EX
-              yield
-            ensure
-              f.flock File::LOCK_UN
-            end
-          end
-        end
-
         def logfile
           ParallelTests::Test::Runner.runtime_log
         end
@@ -75,54 +75,26 @@ end
 
 if defined?(Minitest::Runnable) # Minitest 5
   class << Minitest::Runnable
-    alias_method :run_without_runtime_log, :run
-    def run(*args)
-      ParallelTests::Test::RuntimeLogger.log_test_run(self) do
-        run_without_runtime_log(*args)
+    prepend(
+      Module.new do
+        def run(*)
+          ParallelTests::Test::RuntimeLogger.log_test_run(self) do
+            super
+          end
+        end
       end
-    end
+    )
   end
 
   class << Minitest
-    alias_method :run_without_runtime_log, :run
-    def run(*args)
-      result = run_without_runtime_log(*args)
-      ParallelTests::Test::RuntimeLogger.unique_log
-      result
-    end
-  end
-elsif defined?(MiniTest::Unit) # Minitest 4
-  MiniTest::Unit.class_eval do
-    alias_method :_run_suite_without_runtime_log, :_run_suite
-    def _run_suite(*args)
-      ParallelTests::Test::RuntimeLogger.log_test_run(args.first) do
-        _run_suite_without_runtime_log(*args)
-      end
-    end
-
-    alias_method :_run_suites_without_runtime_log, :_run_suites
-    def _run_suites(*args)
-      result = _run_suites_without_runtime_log(*args)
-      ParallelTests::Test::RuntimeLogger.unique_log
-      result
-    end
-  end
-else # Test::Unit
-  require 'test/unit/testsuite'
-  class ::Test::Unit::TestSuite
-    alias_method :run_without_timing, :run
-
-    def run(result, &block)
-      test = tests.first
-
-      if test.is_a? ::Test::Unit::TestSuite # all tests ?
-        run_without_timing(result, &block)
-        ParallelTests::Test::RuntimeLogger.unique_log
-      else
-        ParallelTests::Test::RuntimeLogger.log_test_run(test.class) do
-          run_without_timing(result, &block)
+    prepend(
+      Module.new do
+        def run(*args)
+          result = super
+          ParallelTests::Test::RuntimeLogger.unique_log
+          result
         end
       end
-    end
+    )
   end
 end

data/lib/parallel_tests/version.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module ParallelTests
-  VERSION = Version = '1.3.7'
+  VERSION = '3.7.3'
 end

data/lib/parallel_tests.rb

@@ -1,19 +1,16 @@
+# frozen_string_literal: true
 require "parallel"
 require "parallel_tests/railtie" if defined? Rails::Railtie
 require "rbconfig"
 
 module ParallelTests
   WINDOWS = (RbConfig::CONFIG['host_os'] =~ /cygwin|mswin|mingw|bccwin|wince|emx/)
-  GREP_PROCESSES_COMMAND = \
-  if WINDOWS
-    "wmic process get commandline | findstr TEST_ENV_NUMBER | find /c \"TEST_ENV_NUMBER=\" 2>&1"
-  else
-    "ps -ef | grep [T]EST_ENV_NUMBER= 2>&1"
-  end
+  RUBY_BINARY = File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name'])
 
   autoload :CLI, "parallel_tests/cli"
   autoload :VERSION, "parallel_tests/version"
   autoload :Grouper, "parallel_tests/grouper"
+  autoload :Pids, "parallel_tests/pids"
 
   class << self
     def determine_number_of_processes(count)
@@ -21,7 +18,32 @@ module ParallelTests
         count,
         ENV["PARALLEL_TEST_PROCESSORS"],
         Parallel.processor_count
-      ].detect{|c| not c.to_s.strip.empty? }.to_i
+      ].detect { |c| !c.to_s.strip.empty? }.to_i
+    end
+
+    def with_pid_file
+      Tempfile.open('parallel_tests-pidfile') do |f|
+        ENV['PARALLEL_PID_FILE'] = f.path
+        # Pids object should be created before threads will start adding pids to it
+        # Otherwise we would have to use Mutex to prevent creation of several instances
+        @pids = pids
+        yield
+      ensure
+        ENV['PARALLEL_PID_FILE'] = nil
+        @pids = nil
+      end
+    end
+
+    def pids
+      @pids ||= Pids.new(pid_file_path)
+    end
+
+    def pid_file_path
+      ENV.fetch('PARALLEL_PID_FILE')
+    end
+
+    def stop_all_processes
+      pids.all.each { |pid| Process.kill(:INT, pid) }
     end
 
     # copied from http://github.com/carlhuda/bundler Bundler::SharedHelpers#find_gemfile
@@ -34,14 +56,27 @@ module ParallelTests
       until !File.directory?(current) || current == previous
         filename = File.join(current, "Gemfile")
         return true if File.exist?(filename)
-        current, previous = File.expand_path("..", current), current
+        previous = current
+        current = File.expand_path("..", current)
       end
 
       false
     end
 
     def first_process?
-      !ENV["TEST_ENV_NUMBER"] || ENV["TEST_ENV_NUMBER"].to_i == 0
+      ENV["TEST_ENV_NUMBER"].to_i <= 1
+    end
+
+    def last_process?
+      current_process_number = ENV['TEST_ENV_NUMBER']
+      total_processes = ENV['PARALLEL_TEST_GROUPS']
+      return true if current_process_number.nil? && total_processes.nil?
+      current_process_number = '1' if current_process_number.nil?
+      current_process_number == total_processes
+    end
+
+    def with_ruby_binary(command)
+      WINDOWS ? "#{RUBY_BINARY} -- #{command}" : command
     end
 
     def wait_for_other_processes_to_finish
@@ -49,20 +84,12 @@ module ParallelTests
       sleep 1 until number_of_running_processes <= 1
     end
 
-    # Fun fact: this includes the current process if it's run via parallel_tests
     def number_of_running_processes
-      result = `#{GREP_PROCESSES_COMMAND}`
-      raise "Could not grep for processes -> #{result}" if result.strip != "" && !$?.success?
-      result.split("\n").size
+      pids.count
     end
 
-    # real time even if someone messed with timecop in tests
     def now
-      if Time.respond_to?(:now_without_mock_time) # Timecop
-        Time.now_without_mock_time
-      else
-        Time.now
-      end
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
     end
 
     def delta

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parallel_tests
 version: !ruby/object:Gem::Version
-  version: 1.3.7
+  version: 3.7.3
 platform: ruby
 authors:
 - Michael Grosser
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-12 00:00:00.000000000 Z
+date: 2021-09-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parallel
@@ -42,6 +42,7 @@ files:
 - lib/parallel_tests.rb
 - lib/parallel_tests/cli.rb
 - lib/parallel_tests/cucumber/failures_logger.rb
+- lib/parallel_tests/cucumber/features_with_steps.rb
 - lib/parallel_tests/cucumber/runner.rb
 - lib/parallel_tests/cucumber/scenario_line_logger.rb
 - lib/parallel_tests/cucumber/scenarios.rb
@@ -50,6 +51,7 @@ files:
 - lib/parallel_tests/gherkin/runner.rb
 - lib/parallel_tests/gherkin/runtime_logger.rb
 - lib/parallel_tests/grouper.rb
+- lib/parallel_tests/pids.rb
 - lib/parallel_tests/railtie.rb
 - lib/parallel_tests/rspec/failures_logger.rb
 - lib/parallel_tests/rspec/logger_base.rb
@@ -61,10 +63,14 @@ files:
 - lib/parallel_tests/test/runner.rb
 - lib/parallel_tests/test/runtime_logger.rb
 - lib/parallel_tests/version.rb
-homepage: http://github.com/grosser/parallel_tests
+homepage: https://github.com/grosser/parallel_tests
 licenses:
 - MIT
-metadata: {}
+metadata:
+  bug_tracker_uri: https://github.com/grosser/parallel_tests/issues
+  documentation_uri: https://github.com/grosser/parallel_tests/blob/v3.7.3/Readme.md
+  source_code_uri: https://github.com/grosser/parallel_tests/tree/v3.7.3
+  wiki_uri: https://github.com/grosser/parallel_tests/wiki
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -73,15 +79,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.9.3
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 3.2.16
 signing_key: 
 specification_version: 4
 summary: Run Test::Unit / RSpec / Cucumber / Spinach in parallel