parallel_tests 3.7.3 → 4.7.2

data/lib/parallel_tests/rspec/failures_logger.rb

@@ -3,22 +3,14 @@ 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
-  else
-    RSpec::Core::Formatters.register self, :dump_summary
-  end
+  RSpec::Core::Formatters.register(self, :dump_summary)
 
   def dump_summary(*args)
     lock_output do
-      if RSPEC_2
-        dump_commands_to_rerun_failed_examples
-      else
-        notification = args.first
-        unless notification.failed_examples.empty?
-          colorizer = ::RSpec::Core::Formatters::ConsoleCodes
-          output.puts notification.colorized_rerun_commands(colorizer)
-        end
+      notification = args.first
+      unless notification.failed_examples.empty?
+        colorizer = ::RSpec::Core::Formatters::ConsoleCodes
+        output.puts notification.colorized_rerun_commands(colorizer)
       end
     end
     @output.flush

data/lib/parallel_tests/rspec/logger_base.rb

@@ -7,8 +7,6 @@ end
 require 'rspec/core/formatters/base_text_formatter'
 
 class ParallelTests::RSpec::LoggerBase < RSpec::Core::Formatters::BaseTextFormatter
-  RSPEC_2 = RSpec::Core::Version::STRING.start_with?('2')
-
   def initialize(*args)
     super
 

data/lib/parallel_tests/rspec/runner.rb

@@ -7,8 +7,7 @@ module ParallelTests
       DEV_NULL = (WINDOWS ? "NUL" : "/dev/null")
       class << self
         def run_tests(test_files, process_number, num_processes, options)
-          exe = executable # expensive, so we cache
-          cmd = [exe, options[:test_options], color, spec_opts, *test_files].compact.join(" ")
+          cmd = [*executable, *options[:test_options], *color, *spec_opts, *test_files]
           execute_command(cmd, process_number, num_processes, options)
         end
 
@@ -16,9 +15,9 @@ module ParallelTests
           if File.exist?("bin/rspec")
             ParallelTests.with_ruby_binary("bin/rspec")
           elsif ParallelTests.bundler_enabled?
-            "bundle exec rspec"
+            ["bundle", "exec", "rspec"]
           else
-            "rspec"
+            ["rspec"]
           end
         end
 
@@ -34,8 +33,10 @@ module ParallelTests
           "spec"
         end
 
+        # used to find all _spec.rb files
+        # supports also feature files used by rspec turnip extension
         def test_suffix
-          /_spec\.rb$/
+          /(_spec\.rb|\.feature)$/
         end
 
         def line_is_result?(line)
@@ -48,8 +49,8 @@ module ParallelTests
         # --order rand:1234
         # --order random:1234
         def command_with_seed(cmd, seed)
-          clean = cmd.sub(/\s--(seed\s+\d+|order\s+rand(om)?(:\d+)?)\b/, '')
-          "#{clean} --seed #{seed}"
+          clean = remove_command_arguments(cmd, '--seed', '--order')
+          [*clean, '--seed', seed]
         end
 
         # Summarize results from threads and colorize results based on failure and pending counts.
@@ -71,19 +72,13 @@ module ParallelTests
 
         private
 
-        # so it can be stubbed....
-        def run(cmd)
-          `#{cmd}`
-        end
-
         def color
-          '--color --tty' if $stdout.tty?
+          ['--color', '--tty'] if $stdout.tty?
         end
 
         def spec_opts
           options_file = ['.rspec_parallel', 'spec/parallel_spec.opts', 'spec/spec.opts'].detect { |f| File.file?(f) }
-          return unless options_file
-          "-O #{options_file}"
+          ["-O", options_file] if options_file
         end
       end
     end

data/lib/parallel_tests/rspec/runtime_logger.rb

@@ -9,7 +9,7 @@ class ParallelTests::RSpec::RuntimeLogger < ParallelTests::RSpec::LoggerBase
     @group_nesting = 0
   end
 
-  RSpec::Core::Formatters.register self, :example_group_started, :example_group_finished, :start_dump unless RSPEC_2
+  RSpec::Core::Formatters.register(self, :example_group_started, :example_group_finished, :start_dump)
 
   def example_group_started(example_group)
     @time = ParallelTests.now if @group_nesting == 0
@@ -20,8 +20,7 @@ class ParallelTests::RSpec::RuntimeLogger < ParallelTests::RSpec::LoggerBase
   def example_group_finished(notification)
     @group_nesting -= 1
     if @group_nesting == 0
-      path = (RSPEC_2 ? notification.file_path : notification.group.file_path)
-      @example_times[path] += ParallelTests.now - @time
+      @example_times[notification.group.file_path] += ParallelTests.now - @time
     end
     super if defined?(super)
   end
@@ -37,9 +36,11 @@ class ParallelTests::RSpec::RuntimeLogger < ParallelTests::RSpec::LoggerBase
   def start_dump(*)
     return unless ENV['TEST_ENV_NUMBER'] # only record when running in parallel
     lock_output do
+      # Order the output from slowest to fastest
+      @example_times = @example_times.sort_by(&:last).reverse
       @example_times.each do |file, time|
         relative_path = file.sub(%r{^#{Regexp.escape Dir.pwd}/}, '').sub(%r{^\./}, "")
-        @output.puts "#{relative_path}:#{time > 0 ? time : 0}"
+        @output.puts "#{relative_path}:#{[time, 0].max}"
       end
     end
     @output.flush

data/lib/parallel_tests/rspec/summary_logger.rb

@@ -2,7 +2,7 @@
 require 'parallel_tests/rspec/failures_logger'
 
 class ParallelTests::RSpec::SummaryLogger < ParallelTests::RSpec::LoggerBase
-  RSpec::Core::Formatters.register self, :dump_failures unless RSPEC_2
+  RSpec::Core::Formatters.register(self, :dump_failures)
 
   def dump_failures(*args)
     lock_output { super }

data/lib/parallel_tests/rspec/verbose_logger.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'rspec/core/formatters/base_text_formatter'
+require 'parallel_tests/rspec/runner'
+
+class ParallelTests::RSpec::VerboseLogger < RSpec::Core::Formatters::BaseTextFormatter
+  RSpec::Core::Formatters.register(
+    self,
+    :example_group_started,
+    :example_group_finished,
+    :example_started,
+    :example_passed,
+    :example_pending,
+    :example_failed
+  )
+
+  def initialize(output)
+    super
+    @line = []
+  end
+
+  def example_group_started(notification)
+    @line.push(notification.group.description)
+  end
+
+  def example_group_finished(_notification)
+    @line.pop
+  end
+
+  def example_started(notification)
+    @line.push(notification.example.description)
+    output_formatted_line('STARTED', :yellow)
+  end
+
+  def example_passed(_passed)
+    output_formatted_line('PASSED', :success)
+    @line.pop
+  end
+
+  def example_pending(_pending)
+    output_formatted_line('PENDING', :pending)
+    @line.pop
+  end
+
+  def example_failed(_failure)
+    output_formatted_line('FAILED', :failure)
+    @line.pop
+  end
+
+  private
+
+  def output_formatted_line(status, console_code)
+    prefix = ["[#{Process.pid}]"]
+    if ENV.include?('TEST_ENV_NUMBER')
+      test_env_number = ENV['TEST_ENV_NUMBER'] == '' ? 1 : Integer(ENV['TEST_ENV_NUMBER'])
+      prefix << "[#{test_env_number}]"
+    end
+    prefix << RSpec::Core::Formatters::ConsoleCodes.wrap("[#{status}]", console_code)
+
+    output.puts [*prefix, *@line].join(' ')
+  end
+end

data/lib/parallel_tests/spinach/runner.rb

@@ -15,7 +15,7 @@ module ParallelTests
 
         def runtime_logging
           # Not Yet Supported
-          ""
+          []
         end
       end
     end

data/lib/parallel_tests/tasks.rb

@@ -9,16 +9,8 @@ module ParallelTests
         'test'
       end
 
-      def rake_bin
-        # Prevent 'Exec format error' Errno::ENOEXEC on Windows
-        return "rake" if RUBY_PLATFORM =~ /mswin|mingw|cygwin/
-        binstub_path = File.join('bin', 'rake')
-        return binstub_path if File.exist?(binstub_path)
-        "rake"
-      end
-
       def load_lib
-        $LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), '..'))
+        $LOAD_PATH << File.expand_path('..', __dir__)
         require "parallel_tests"
       end
 
@@ -30,12 +22,15 @@ module ParallelTests
 
       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', __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)
+        command = ParallelTests.with_ruby_binary(executable)
+        command += ['--exec', Shellwords.join(cmd)]
+        command += ['-n', options[:count]] unless options[:count].to_s.empty?
+        command << '--non-parallel' if options[:non_parallel]
+
+        abort unless system(*command)
       end
 
       # this is a crazy-complex solution for a very simple problem:
@@ -48,16 +43,17 @@ module ParallelTests
       # - pipefail makes pipe fail with exitstatus of first failed command
       # - pipefail is not supported in (zsh)
       # - defining a new rake task like silence_schema would force users to load parallel_tests in test env
-      # - do not use ' since run_in_parallel uses them to quote stuff
       # - 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 = %{(grep -v "#{ignore_regex}" || test 1)}
+        remove_ignored_lines = %{(grep -v #{Shellwords.escape(ignore_regex)} || true)}
 
-        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
-          %{/bin/bash -c '"'"'#{activate_pipefail} && (#{command}) | #{remove_ignored_lines}'"'"'}
+        # remove nil values (ex: #purge_before_load returns nil)
+        command.compact!
+
+        if system('/bin/bash', '-c', "#{activate_pipefail} 2>/dev/null")
+          shell_command = "#{activate_pipefail} && (#{Shellwords.shelljoin(command)}) | #{remove_ignored_lines}"
+          ['/bin/bash', '-c', shell_command]
         else
           command
         end
@@ -90,7 +86,74 @@ module ParallelTests
         options = args.shift
         pass_through = args.shift
 
-        [num_processes, pattern.to_s, options.to_s, pass_through.to_s]
+        [num_processes, pattern, options, pass_through]
+      end
+
+      def schema_format_based_on_rails_version
+        if rails_7_or_greater?
+          ActiveRecord.schema_format
+        else
+          ActiveRecord::Base.schema_format
+        end
+      end
+
+      def schema_type_based_on_rails_version
+        if rails_61_or_greater? || schema_format_based_on_rails_version == :ruby
+          "schema"
+        else
+          "structure"
+        end
+      end
+
+      def build_run_command(type, args)
+        count, pattern, options, pass_through = ParallelTests::Tasks.parse_args(args)
+        test_framework = {
+          'spec' => 'rspec',
+          'test' => 'test',
+          'features' => 'cucumber',
+          'features-spinach' => 'spinach'
+        }.fetch(type)
+
+        type = 'features' if test_framework == 'spinach'
+
+        # Using the relative path to find the binary allow to run a specific version of it
+        executable = File.expand_path('../../bin/parallel_test', __dir__)
+        executable = ParallelTests.with_ruby_binary(executable)
+
+        command = [*executable, type, '--type', test_framework]
+        command += ['-n', count.to_s] if count
+        command += ['--pattern', pattern] if pattern
+        command += ['--test-options', options] if options
+        command += Shellwords.shellsplit pass_through if pass_through
+        command
+      end
+
+      def configured_databases
+        return [] unless defined?(ActiveRecord) && rails_61_or_greater?
+
+        @@configured_databases ||= ActiveRecord::Tasks::DatabaseTasks.setup_initial_database_yaml
+      end
+
+      def for_each_database(&block)
+        # Use nil to represent all databases
+        block&.call(nil)
+
+        # skip if not rails or old rails version
+        return if !defined?(ActiveRecord::Tasks::DatabaseTasks) || !ActiveRecord::Tasks::DatabaseTasks.respond_to?(:for_each)
+
+        ActiveRecord::Tasks::DatabaseTasks.for_each(configured_databases) do |name|
+          block&.call(name)
+        end
+      end
+
+      private
+
+      def rails_7_or_greater?
+        Gem::Version.new(Rails.version) >= Gem::Version.new('7.0')
+      end
+
+      def rails_61_or_greater?
+        Gem::Version.new(Rails.version) >= Gem::Version.new('6.1.0')
       end
     end
   end
@@ -99,36 +162,46 @@ end
 namespace :parallel do
   desc "Setup test databases via db:setup --> parallel:setup[num_cpus]"
   task :setup, :count do |_, args|
-    command = "#{ParallelTests::Tasks.rake_bin} db:setup RAILS_ENV=#{ParallelTests::Tasks.rails_env}"
+    command = [$0, "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|
-    ParallelTests::Tasks.run_in_parallel(
-      "#{ParallelTests::Tasks.rake_bin} db:create RAILS_ENV=#{ParallelTests::Tasks.rails_env}", args
-    )
+  ParallelTests::Tasks.for_each_database do |name|
+    task_name = 'create'
+    task_name += ":#{name}" if name
+    desc "Create test#{" #{name}" if name} database via db:#{task_name} --> parallel:#{task_name}[num_cpus]"
+    task task_name.to_sym, :count do |_, args|
+      ParallelTests::Tasks.run_in_parallel(
+        [$0, "db:#{task_name}", "RAILS_ENV=#{ParallelTests::Tasks.rails_env}"],
+        args
+      )
+    end
   end
 
-  desc "Drop test databases via db:drop --> parallel:drop[num_cpus]"
-  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
-    )
+  ParallelTests::Tasks.for_each_database do |name|
+    task_name = 'drop'
+    task_name += ":#{name}" if name
+    desc "Drop test#{" #{name}" if name} database via db:#{task_name} --> parallel:#{task_name}[num_cpus]"
+    task task_name.to_sym, :count do |_, args|
+      ParallelTests::Tasks.run_in_parallel(
+        [
+          $0,
+          "db:#{task_name}",
+          "RAILS_ENV=#{ParallelTests::Tasks.rails_env}",
+          "DISABLE_DATABASE_ENVIRONMENT_CHECK=1"
+        ],
+        args
+      )
+    end
   end
 
   desc "Update test databases by dumping and loading --> parallel:prepare[num_cpus]"
   task(:prepare, [:count]) do |_, args|
     ParallelTests::Tasks.check_for_pending_migrations
-    if defined?(ActiveRecord::Base) && [:ruby, :sql].include?(ActiveRecord::Base.schema_format)
+
+    if defined?(ActiveRecord) && [:ruby, :sql].include?(ParallelTests::Tasks.schema_format_based_on_rails_version)
       # fast: dump once, load in parallel
-      type =
-        if Gem::Version.new(Rails.version) >= Gem::Version.new('6.1.0')
-          "schema"
-        else
-          ActiveRecord::Base.schema_format == :ruby ? "schema" : "structure"
-        end
+      type = ParallelTests::Tasks.schema_type_based_on_rails_version
 
       Rake::Task["db:#{type}:dump"].invoke
 
@@ -140,32 +213,51 @@ namespace :parallel do
       # slow: dump and load in in serial
       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)
+      ParallelTests::Tasks.run_in_parallel([$0, task_name], args)
       next
     end
   end
 
   # when dumping/resetting takes too long
-  desc "Update test databases via db:migrate --> parallel:migrate[num_cpus]"
-  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.for_each_database do |name|
+    task_name = 'migrate'
+    task_name += ":#{name}" if name
+    desc "Update test#{" #{name}" if name} database via db:#{task_name} --> parallel:#{task_name}[num_cpus]"
+    task task_name.to_sym, :count do |_, args|
+      ParallelTests::Tasks.run_in_parallel(
+        [$0, "db:#{task_name}", "RAILS_ENV=#{ParallelTests::Tasks.rails_env}"],
+        args
+      )
+    end
   end
 
   desc "Rollback test databases via db:rollback --> parallel:rollback[num_cpus]"
   task :rollback, :count do |_, args|
     ParallelTests::Tasks.run_in_parallel(
-      "#{ParallelTests::Tasks.rake_bin} db:rollback RAILS_ENV=#{ParallelTests::Tasks.rails_env}", args
+      [$0, "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|
-    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)
+  ParallelTests::Tasks.for_each_database do |name|
+    rails_task = 'db:schema:load'
+    rails_task += ":#{name}" if name
+
+    task_name = 'load_schema'
+    task_name += ":#{name}" if name
+
+    desc "Load dumped schema for test#{" #{name}" if name} database via #{rails_task} --> parallel:#{task_name}[num_cpus]"
+    task task_name.to_sym, :count do |_, args|
+      command = [
+        $0,
+        ParallelTests::Tasks.purge_before_load,
+        rails_task,
+        "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
   end
 
   # load the structure from the structure.sql file
@@ -173,23 +265,34 @@ namespace :parallel do
   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
+      [
+        $0,
+        ParallelTests::Tasks.purge_before_load,
+        "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|
     ParallelTests::Tasks.run_in_parallel(
-      "#{ParallelTests::Tasks.rake_bin} db:seed RAILS_ENV=#{ParallelTests::Tasks.rails_env}", args
+      [
+        $0,
+        "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
+      [$0, args.command, "RAILS_ENV=#{ParallelTests::Tasks.rails_env}"],
+      args
     )
   end
 
@@ -198,26 +301,9 @@ namespace :parallel do
     task type, [:count, :pattern, :options, :pass_through] do |_t, args|
       ParallelTests::Tasks.check_for_pending_migrations
       ParallelTests::Tasks.load_lib
+      command = ParallelTests::Tasks.build_run_command(type, args)
 
-      count, pattern, options, pass_through = ParallelTests::Tasks.parse_args(args)
-      test_framework = {
-        'spec' => 'rspec',
-        'test' => 'test',
-        'features' => 'cucumber',
-        'features-spinach' => 'spinach'
-      }[type]
-
-      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')
-
-      command = "#{ParallelTests.with_ruby_binary(Shellwords.escape(executable))} #{type} " \
-        "--type #{test_framework} "        \
-        "-n #{count} "                     \
-        "--pattern '#{pattern}' "          \
-        "--test-options '#{options}' "     \
-        "#{pass_through}"
-      abort unless system(command) # allow to chain tasks e.g. rake parallel:spec parallel:features
+      abort unless system(*command) # allow to chain tasks e.g. rake parallel:spec parallel:features
     end
   end
 end