parallel_tests 3.2.0 → 3.5.2

data/lib/parallel_tests/rspec/failures_logger.rb

@@ -1,10 +1,10 @@
+# frozen_string_literal: true
 require 'parallel_tests/rspec/logger_base'
 require 'parallel_tests/rspec/runner'
 
 class ParallelTests::RSpec::FailuresLogger < ParallelTests::RSpec::LoggerBase
   if RSPEC_2
-    def dump_failures(*args)
-    end
+    def dump_failures(*args); end
   else
     RSpec::Core::Formatters.register self, :dump_summary
   end

data/lib/parallel_tests/rspec/logger_base.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module ParallelTests
   module RSpec
   end
@@ -13,26 +14,27 @@ class ParallelTests::RSpec::LoggerBase < RSpec::Core::Formatters::BaseTextFormat
 
     @output ||= args[0]
 
-    if String === @output # a path ?
+    case @output
+    when String # a path ?
       FileUtils.mkdir_p(File.dirname(@output))
-      File.open(@output, 'w'){} # overwrite previous results
+      File.open(@output, 'w') {} # overwrite previous results
       @output = File.open(@output, 'a')
-    elsif File === @output # close and restart in append mode
+    when File # close and restart in append mode
       @output.close
       @output = File.open(@output.path, 'a')
     end
   end
 
-  #stolen from Rspec
-  def close(*args)
-    @output.close  if (IO === @output) & (@output != $stdout)
+  # stolen from Rspec
+  def close(*)
+    @output.close if (IO === @output) & (@output != $stdout)
   end
 
   protected
 
   # do not let multiple processes get in each others way
   def lock_output
-    if File === @output
+    if @output.is_a?(File)
       begin
         @output.flock File::LOCK_EX
         yield

data/lib/parallel_tests/rspec/runner.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "parallel_tests/test/runner"
 
 module ParallelTests
@@ -12,10 +13,9 @@ module ParallelTests
         end
 
         def determine_executable
-          case
-          when File.exist?("bin/rspec")
+          if File.exist?("bin/rspec")
             ParallelTests.with_ruby_binary("bin/rspec")
-          when ParallelTests.bundler_enabled?
+          elsif ParallelTests.bundler_enabled?
             "bundle exec rspec"
           else
             "rspec"
@@ -23,7 +23,7 @@ module ParallelTests
         end
 
         def runtime_log
-          'tmp/parallel_runtime_rspec.log'
+          "tmp/parallel_runtime_rspec.log"
         end
 
         def test_file_name
@@ -48,6 +48,22 @@ module ParallelTests
           "#{clean} --seed #{seed}"
         end
 
+        # Summarize results from threads and colorize results based on failure and pending counts.
+        #
+        def summarize_results(results)
+          text = super
+          return text unless $stdout.tty?
+          sums = sum_up_results(results)
+          color =
+            if sums['failure'] > 0
+              31 # red
+            elsif sums['pending'] > 0
+              33 # yellow
+            else
+              32 # green
+            end
+          "\e[#{color}m#{text}\e[0m"
+        end
 
         private
 
@@ -61,7 +77,7 @@ module ParallelTests
         end
 
         def spec_opts
-          options_file = ['.rspec_parallel', 'spec/parallel_spec.opts', 'spec/spec.opts'].detect{|f| File.file?(f) }
+          options_file = ['.rspec_parallel', 'spec/parallel_spec.opts', 'spec/spec.opts'].detect { |f| File.file?(f) }
           return unless options_file
           "-O #{options_file}"
         end

data/lib/parallel_tests/rspec/runtime_logger.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'parallel_tests'
 require 'parallel_tests/rspec/logger_base'
 
@@ -8,9 +9,7 @@ class ParallelTests::RSpec::RuntimeLogger < ParallelTests::RSpec::LoggerBase
     @group_nesting = 0
   end
 
-  unless RSPEC_2
-    RSpec::Core::Formatters.register self, :example_group_started, :example_group_finished, :start_dump
-  end
+  RSpec::Core::Formatters.register self, :example_group_started, :example_group_finished, :start_dump unless RSPEC_2
 
   def example_group_started(example_group)
     @time = ParallelTests.now if @group_nesting == 0
@@ -27,16 +26,19 @@ class ParallelTests::RSpec::RuntimeLogger < ParallelTests::RSpec::LoggerBase
     super if defined?(super)
   end
 
-  def dump_summary(*args);end
-  def dump_failures(*args);end
-  def dump_failure(*args);end
-  def dump_pending(*args);end
+  def dump_summary(*); end
+
+  def dump_failures(*); end
+
+  def dump_failure(*); end
+
+  def dump_pending(*); end
 
-  def start_dump(*args)
-    return unless ENV['TEST_ENV_NUMBER'] #only record when running in parallel
+  def start_dump(*)
+    return unless ENV['TEST_ENV_NUMBER'] # only record when running in parallel
     lock_output do
       @example_times.each do |file, time|
-        relative_path = file.sub(/^#{Regexp.escape Dir.pwd}\//,'').sub(/^\.\//, "")
+        relative_path = file.sub(%r{^#{Regexp.escape Dir.pwd}/}, '').sub(%r{^\./}, "")
         @output.puts "#{relative_path}:#{time > 0 ? time : 0}"
       end
     end

data/lib/parallel_tests/rspec/summary_logger.rb

@@ -1,9 +1,8 @@
+# frozen_string_literal: true
 require 'parallel_tests/rspec/failures_logger'
 
 class ParallelTests::RSpec::SummaryLogger < ParallelTests::RSpec::LoggerBase
-  unless RSPEC_2
-    RSpec::Core::Formatters.register self, :dump_failures
-  end
+  RSpec::Core::Formatters.register self, :dump_failures unless RSPEC_2
 
   def dump_failures(*args)
     lock_output { super }

data/lib/parallel_tests/spinach/runner.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "parallel_tests/gherkin/runner"
 
 module ParallelTests
@@ -9,10 +10,9 @@ module ParallelTests
         end
 
         def runtime_logging
-          #Not Yet Supported
+          # Not Yet Supported
           ""
         end
-
       end
     end
   end

data/lib/parallel_tests/tasks.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'rake'
 require 'shellwords'
 
@@ -27,12 +28,13 @@ module ParallelTests
         end
       end
 
-      def run_in_parallel(cmd, options={})
+      def run_in_parallel(cmd, options = {})
         load_lib
         count = " -n #{options[:count]}" unless options[:count].to_s.empty?
         # Using the relative path to find the binary allow to run a specific version of it
-        executable = File.expand_path("../../../bin/parallel_test", __FILE__)
-        command = "#{ParallelTests.with_ruby_binary(Shellwords.escape(executable))} --exec '#{cmd}'#{count}#{' --non-parallel' if options[:non_parallel]}"
+        executable = File.expand_path('../../bin/parallel_test', __dir__)
+        non_parallel = (options[:non_parallel] ? ' --non-parallel' : '')
+        command = "#{ParallelTests.with_ruby_binary(Shellwords.escape(executable))} --exec '#{cmd}'#{count}#{non_parallel}"
         abort unless system(command)
       end
 
@@ -50,12 +52,12 @@ module ParallelTests
       # - simple system "set -o pipefail" returns nil even though set -o pipefail exists with 0
       def suppress_output(command, ignore_regex)
         activate_pipefail = "set -o pipefail"
-        remove_ignored_lines = %Q{(grep -v "#{ignore_regex}" || test 1)}
+        remove_ignored_lines = %{(grep -v "#{ignore_regex}" || test 1)}
 
         if File.executable?('/bin/bash') && system('/bin/bash', '-c', "#{activate_pipefail} 2>/dev/null && test 1")
           # We need to shell escape single quotes (' becomes '"'"') because
           # run_in_parallel wraps command in single quotes
-          %Q{/bin/bash -c '"'"'#{activate_pipefail} && (#{command}) | #{remove_ignored_lines}'"'"'}
+          %{/bin/bash -c '"'"'#{activate_pipefail} && (#{command}) | #{remove_ignored_lines}'"'"'}
         else
           command
         end
@@ -83,7 +85,7 @@ module ParallelTests
         # parallel:spec[2,models,options]
         # parallel:spec[,models,options]
         count = args.shift if args.first.to_s =~ /^\d*$/
-        num_processes = count.to_i unless count.to_s.empty?
+        num_processes = (count.to_s.empty? ? nil : Integer(count))
         pattern = args.shift
         options = args.shift
         pass_through = args.shift
@@ -96,30 +98,38 @@ end
 
 namespace :parallel do
   desc "Setup test databases via db:setup --> parallel:setup[num_cpus]"
-  task :setup, :count do |_,args|
+  task :setup, :count do |_, args|
     command = "#{ParallelTests::Tasks.rake_bin} db:setup RAILS_ENV=#{ParallelTests::Tasks.rails_env}"
     ParallelTests::Tasks.run_in_parallel(ParallelTests::Tasks.suppress_schema_load_output(command), args)
   end
 
   desc "Create test databases via db:create --> parallel:create[num_cpus]"
-  task :create, :count do |_,args|
+  task :create, :count do |_, args|
     ParallelTests::Tasks.run_in_parallel(
-      "#{ParallelTests::Tasks.rake_bin} db:create RAILS_ENV=#{ParallelTests::Tasks.rails_env}", args)
+      "#{ParallelTests::Tasks.rake_bin} db:create RAILS_ENV=#{ParallelTests::Tasks.rails_env}", args
+    )
   end
 
   desc "Drop test databases via db:drop --> parallel:drop[num_cpus]"
-  task :drop, :count do |_,args|
+  task :drop, :count do |_, args|
     ParallelTests::Tasks.run_in_parallel(
       "#{ParallelTests::Tasks.rake_bin} db:drop RAILS_ENV=#{ParallelTests::Tasks.rails_env} " \
-      "DISABLE_DATABASE_ENVIRONMENT_CHECK=1", args)
+      "DISABLE_DATABASE_ENVIRONMENT_CHECK=1", args
+    )
   end
 
   desc "Update test databases by dumping and loading --> parallel:prepare[num_cpus]"
-  task(:prepare, [:count]) do |_,args|
+  task(:prepare, [:count]) do |_, args|
     ParallelTests::Tasks.check_for_pending_migrations
     if defined?(ActiveRecord::Base) && [:ruby, :sql].include?(ActiveRecord::Base.schema_format)
       # fast: dump once, load in parallel
-      type = (ActiveRecord::Base.schema_format == :ruby ? "schema" : "structure")
+      type =
+        if Gem::Version.new(Rails.version) >= Gem::Version.new('6.1.0')
+          "schema"
+        else
+          ActiveRecord::Base.schema_format == :ruby ? "schema" : "structure"
+        end
+
       Rake::Task["db:#{type}:dump"].invoke
 
       # remove database connection to prevent "database is being accessed by other users"
@@ -128,7 +138,7 @@ namespace :parallel do
       Rake::Task["parallel:load_#{type}"].invoke(args[:count])
     else
       # slow: dump and load in in serial
-      args = args.to_hash.merge(:non_parallel => true) # normal merge returns nil
+      args = args.to_hash.merge(non_parallel: true) # normal merge returns nil
       task_name = Rake::Task.task_defined?('db:test:prepare') ? 'db:test:prepare' : 'app:db:test:prepare'
       ParallelTests::Tasks.run_in_parallel("#{ParallelTests::Tasks.rake_bin} #{task_name}", args)
       next
@@ -137,49 +147,55 @@ namespace :parallel do
 
   # when dumping/resetting takes too long
   desc "Update test databases via db:migrate --> parallel:migrate[num_cpus]"
-  task :migrate, :count do |_,args|
+  task :migrate, :count do |_, args|
     ParallelTests::Tasks.run_in_parallel(
-      "#{ParallelTests::Tasks.rake_bin} db:migrate RAILS_ENV=#{ParallelTests::Tasks.rails_env}", args)
+      "#{ParallelTests::Tasks.rake_bin} db:migrate RAILS_ENV=#{ParallelTests::Tasks.rails_env}", args
+    )
   end
 
   desc "Rollback test databases via db:rollback --> parallel:rollback[num_cpus]"
-  task :rollback, :count do |_,args|
+  task :rollback, :count do |_, args|
     ParallelTests::Tasks.run_in_parallel(
-      "#{ParallelTests::Tasks.rake_bin} db:rollback RAILS_ENV=#{ParallelTests::Tasks.rails_env}", args)
+      "#{ParallelTests::Tasks.rake_bin} db:rollback RAILS_ENV=#{ParallelTests::Tasks.rails_env}", args
+    )
   end
 
   # just load the schema (good for integration server <-> no development db)
   desc "Load dumped schema for test databases via db:schema:load --> parallel:load_schema[num_cpus]"
-  task :load_schema, :count do |_,args|
+  task :load_schema, :count do |_, args|
     command = "#{ParallelTests::Tasks.rake_bin} #{ParallelTests::Tasks.purge_before_load} " \
       "db:schema:load RAILS_ENV=#{ParallelTests::Tasks.rails_env} DISABLE_DATABASE_ENVIRONMENT_CHECK=1"
     ParallelTests::Tasks.run_in_parallel(ParallelTests::Tasks.suppress_schema_load_output(command), args)
   end
 
   # load the structure from the structure.sql file
-  desc "Load structure for test databases via db:structure:load --> parallel:load_structure[num_cpus]"
-  task :load_structure, :count do |_,args|
+  # (faster for rails < 6.1, deprecated after and only configured by `ActiveRecord::Base.schema_format`)
+  desc "Load structure for test databases via db:schema:load --> parallel:load_structure[num_cpus]"
+  task :load_structure, :count do |_, args|
     ParallelTests::Tasks.run_in_parallel(
       "#{ParallelTests::Tasks.rake_bin} #{ParallelTests::Tasks.purge_before_load} " \
-      "db:structure:load RAILS_ENV=#{ParallelTests::Tasks.rails_env} DISABLE_DATABASE_ENVIRONMENT_CHECK=1", args)
+      "db:structure:load RAILS_ENV=#{ParallelTests::Tasks.rails_env} DISABLE_DATABASE_ENVIRONMENT_CHECK=1", args
+    )
   end
 
   desc "Load the seed data from db/seeds.rb via db:seed --> parallel:seed[num_cpus]"
-  task :seed, :count do |_,args|
+  task :seed, :count do |_, args|
     ParallelTests::Tasks.run_in_parallel(
-      "#{ParallelTests::Tasks.rake_bin} db:seed RAILS_ENV=#{ParallelTests::Tasks.rails_env}", args)
+      "#{ParallelTests::Tasks.rake_bin} db:seed RAILS_ENV=#{ParallelTests::Tasks.rails_env}", args
+    )
   end
 
   desc "Launch given rake command in parallel"
   task :rake, :command, :count do |_, args|
     ParallelTests::Tasks.run_in_parallel(
       "RAILS_ENV=#{ParallelTests::Tasks.rails_env} #{ParallelTests::Tasks.rake_bin} " \
-      "#{args.command}", args)
+      "#{args.command}", args
+    )
   end
 
   ['test', 'spec', 'features', 'features-spinach'].each do |type|
     desc "Run #{type} in parallel with parallel:#{type}[num_cpus]"
-    task type, [:count, :pattern, :options, :pass_through] do |t, args|
+    task type, [:count, :pattern, :options, :pass_through] do |_t, args|
       ParallelTests::Tasks.check_for_pending_migrations
       ParallelTests::Tasks.load_lib
 
@@ -188,12 +204,10 @@ namespace :parallel do
         'spec' => 'rspec',
         'test' => 'test',
         'features' => 'cucumber',
-        'features-spinach' => 'spinach',
+        'features-spinach' => 'spinach'
       }[type]
 
-      if test_framework == 'spinach'
-        type = 'features'
-      end
+      type = 'features' if test_framework == 'spinach'
       # Using the relative path to find the binary allow to run a specific version of it
       executable = File.join(File.dirname(__FILE__), '..', '..', 'bin', 'parallel_test')
 

data/lib/parallel_tests/test/runner.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'parallel_tests'
 
 module ParallelTests
@@ -32,7 +33,7 @@ module ParallelTests
         # --- 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
@@ -46,10 +47,17 @@ module ParallelTests
           when :filesize
             sort_by_filesize(tests)
           when :runtime
-            sort_by_runtime(tests, runtimes(tests, options), options.merge(allowed_missing: (options[:allowed_missing_percent] || 50) / 100.0))
+            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)
@@ -67,7 +75,7 @@ module ParallelTests
           env = (options[:env] || {}).merge(
             "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,
+            "PARALLEL_PID_FILE" => ParallelTests.pid_file_path
           )
           cmd = "nice #{cmd}" if options[:nice]
           cmd = "#{cmd} 2>&1" if options[:combine_stderr]
@@ -86,13 +94,11 @@ module ParallelTests
           end
           ParallelTests.pids.delete(pid) if pid
           exitstatus = $?.exitstatus
-          seed = output[/seed (\d+)/,1]
+          seed = output[/seed (\d+)/, 1]
 
-          if report_process_command?(options) && options[:serialize_stdout]
-            output = [cmd, output].join("\n")
-          end
+          output = [cmd, output].join("\n") if report_process_command?(options) && options[:serialize_stdout]
 
-          {:stdout => output, :exit_status => exitstatus, :command => cmd, :seed => seed}
+          { stdout: output, exit_status: exitstatus, command: cmd, seed: seed }
         end
 
         def find_results(test_output)
@@ -104,7 +110,7 @@ module ParallelTests
           end.compact
         end
 
-        def test_env_number(process_number, options={})
+        def test_env_number(process_number, options = {})
           if process_number == 0 && !options[:first_is_1]
             ''
           else
@@ -114,7 +120,7 @@ module ParallelTests
 
         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
@@ -134,19 +140,18 @@ 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, env, options={})
-          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)
@@ -159,11 +164,13 @@ module ParallelTests
                 $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
 
@@ -178,9 +185,7 @@ module ParallelTests
             [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]
 
           set_unknown_runtime tests, options
         end
@@ -190,7 +195,7 @@ module ParallelTests
           lines = File.read(log).split("\n")
           lines.each_with_object({}) do |line, times|
             test, _, time = line.rpartition(':')
-            next unless test and time
+            next unless test && time
             times[test] = time.to_f if tests.include?(test)
           end
         end
@@ -217,7 +222,7 @@ module ParallelTests
           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
@@ -225,7 +230,7 @@ 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
@@ -236,7 +241,7 @@ module ParallelTests
           known, unknown = tests.partition(&:last)
           return if unknown.empty?
           unknown_runtime = options[:unknown_runtime] ||
-            (known.empty? ? 1 : known.map!(&:last).inject(:+) / known.size) # average
+            (known.empty? ? 1 : known.map!(&:last).sum / known.size) # average
           unknown.each { |set| set[1] = unknown_runtime }
         end