vinted-parallel_tests 0.13.3 → 1.7.0.1

data/lib/parallel_tests/rspec/failures_logger.rb

@@ -2,28 +2,36 @@ require 'parallel_tests/rspec/logger_base'
 require 'parallel_tests/rspec/runner'
 
 class ParallelTests::RSpec::FailuresLogger < ParallelTests::RSpec::LoggerBase
-  # RSpec 1: does not keep track of failures, so we do
-  def example_failed(example, *args)
-    if RSPEC_1
-      @failed_examples ||= []
-      @failed_examples << example
-    else
-      super
+  if RSPEC_1
+    # RSpec 1: does not keep track of failures, so we do
+    def example_failed(example, *args)
+      if RSPEC_1
+        @failed_examples ||= []
+        @failed_examples << example
+      else
+        super
+      end
     end
-  end
 
-  # RSpec 1: dumps 1 failed spec
-  def dump_failure(*args)
-  end
-
-  # RSpec 2: dumps all failed specs
-  def dump_failures(*args)
+    def dump_failure(*args)
+    end
+  elsif RSPEC_2
+    def dump_failures(*args)
+    end
+  else
+    RSpec::Core::Formatters.register self, :dump_summary
   end
 
   def dump_summary(*args)
     lock_output do
       if RSPEC_1
         dump_commands_to_rerun_failed_examples_rspec_1
+      elsif RSPEC_3
+        notification = args.first
+        unless notification.failed_examples.empty?
+          colorizer = ::RSpec::Core::Formatters::ConsoleCodes
+          output.puts notification.colorized_rerun_commands(colorizer)
+        end
       else
         dump_commands_to_rerun_failed_examples
       end

data/lib/parallel_tests/rspec/logger_base.rb

@@ -15,6 +15,8 @@ ParallelTests::RSpec::LoggerBaseBase = base
 
 class ParallelTests::RSpec::LoggerBase < ParallelTests::RSpec::LoggerBaseBase
   RSPEC_1 = !defined?(RSpec::Core::Formatters::BaseTextFormatter) # do not test for Spec, this will trigger deprecation warning in rspec 2
+  RSPEC_2 = !RSPEC_1 && RSpec::Core::Version::STRING.start_with?('2')
+  RSPEC_3 = !RSPEC_1 && RSpec::Core::Version::STRING.start_with?('3')
 
   def initialize(*args)
     super
@@ -32,10 +34,12 @@ class ParallelTests::RSpec::LoggerBase < ParallelTests::RSpec::LoggerBaseBase
   end
 
   #stolen from Rspec
-  def close
+  def close(*args)
     @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

data/lib/parallel_tests/rspec/runner.rb

@@ -3,6 +3,7 @@ require "parallel_tests/test/runner"
 module ParallelTests
   module RSpec
     class Runner < ParallelTests::Test::Runner
+      DEV_NULL = (WINDOWS ? "NUL" : "/dev/null")
       NAME = 'RSpec'
 
       class << self
@@ -16,15 +17,15 @@ module ParallelTests
 
         def determine_executable
           cmd = case
-          when File.exists?("bin/rspec")
-            "bin/rspec"
+          when File.exist?("bin/rspec")
+            WINDOWS ? "ruby bin/rspec" : "bin/rspec"
           when File.file?("script/spec")
             "script/spec"
           when ParallelTests.bundler_enabled?
             cmd = (run("bundle show rspec-core") =~ %r{Could not find gem.*} ? "spec" : "rspec")
             "bundle exec #{cmd}"
           else
-            %w[spec rspec].detect{|cmd| system "#{cmd} --version > /dev/null 2>&1" }
+            %w[spec rspec].detect{|cmd| system "#{cmd} --version > #{DEV_NULL} 2>&1" }
           end
 
           cmd or raise("Can't find executables rspec or spec")
@@ -39,7 +40,7 @@ module ParallelTests
         end
 
         def test_suffix
-          "_spec.rb"
+          /_spec\.rb$/
         end
 
         private

data/lib/parallel_tests/rspec/runtime_logger.rb

@@ -5,7 +5,11 @@ class ParallelTests::RSpec::RuntimeLogger < ParallelTests::RSpec::LoggerBase
   def initialize(*args)
     super
     @example_times = Hash.new(0)
-    @group_nesting = 0 if !RSPEC_1
+    @group_nesting = 0 unless RSPEC_1
+  end
+
+  if RSPEC_3
+    RSpec::Core::Formatters.register self, :example_group_started, :example_group_finished, :start_dump
   end
 
   if RSPEC_1
@@ -26,12 +30,13 @@ class ParallelTests::RSpec::RuntimeLogger < ParallelTests::RSpec::LoggerBase
       super
     end
 
-    def example_group_finished(example_group)
+    def example_group_finished(notification)
       @group_nesting -= 1
       if @group_nesting == 0
-        @example_times[example_group.file_path] += ParallelTests.now - @time
+        path = (RSPEC_3 ? notification.group.file_path : notification.file_path)
+        @example_times[path] += ParallelTests.now - @time
       end
-      super
+      super if defined?(super)
     end
   end
 
@@ -45,7 +50,7 @@ class ParallelTests::RSpec::RuntimeLogger < ParallelTests::RSpec::LoggerBase
     # TODO: Figure out why sometimes time can be less than 0
     lock_output do
       @example_times.each do |file, time|
-        relative_path = file.sub(/^#{Regexp.escape Dir.pwd}\//,'')
+        relative_path = file.sub(/^#{Regexp.escape Dir.pwd}\//,'').sub(/^\.\//, "")
         @output.puts "#{relative_path}:#{time > 0 ? time : 0}"
       end
     end

data/lib/parallel_tests/rspec/summary_logger.rb

@@ -1,19 +1,19 @@
 require 'parallel_tests/rspec/failures_logger'
 
 class ParallelTests::RSpec::SummaryLogger < ParallelTests::RSpec::LoggerBase
-  # RSpec 1: dumps 1 failed spec
-  def dump_failure(*args)
-    lock_output do
-      super
-    end
-    @output.flush
+  if RSPEC_3
+    RSpec::Core::Formatters.register self, :dump_failures
   end
 
-  # RSpec 2: dumps all failed specs
-  def dump_failures(*args)
-    lock_output do
-      super
+  if RSPEC_1
+    def dump_failure(*args)
+      lock_output { super }
+      @output.flush
+    end
+  else
+    def dump_failures(*args)
+      lock_output { super }
+      @output.flush
     end
-    @output.flush
   end
 end

data/lib/parallel_tests/spinach/runner.rb

@@ -0,0 +1,19 @@
+require "parallel_tests/gherkin/runner"
+
+module ParallelTests
+  module Spinach
+    class Runner < ParallelTests::Gherkin::Runner
+      class << self
+        def name
+          'spinach'
+        end
+
+        def runtime_logging
+          #Not Yet Supported
+          ""
+        end
+
+      end
+    end
+  end
+end

data/lib/parallel_tests/tasks.rb

@@ -7,8 +7,12 @@ module ParallelTests
         ENV['RAILS_ENV'] || 'test'
       end
 
+      def purge_before_load
+        "db:test:purge" if Gem::Version.new(Rails.version) > Gem::Version.new('4.2.0')
+      end
+
       def run_in_parallel(cmd, options={})
-        count = " -n #{options[:count]}" if options[:count]
+        count = " -n #{options[:count]}" unless options[:count].to_s.empty?
         executable = File.expand_path("../../../bin/parallel_test", __FILE__)
         command = "#{executable} --exec '#{cmd}'#{count}#{' --non-parallel' if options[:non_parallel]}"
         command << " --advance-number #{options[:advance_number]}" if options[:advance_number]
@@ -31,17 +35,21 @@ module ParallelTests
         activate_pipefail = "set -o pipefail"
         remove_ignored_lines = %Q{(grep -v "#{ignore_regex}" || test 1)}
 
-        if system("#{activate_pipefail} 2>/dev/null && test 1")
-          "#{activate_pipefail} && (#{command}) | #{remove_ignored_lines}"
+        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}'"'"'}
         else
           command
         end
       end
 
       def check_for_pending_migrations
-        abort_migrations = "db:abort_if_pending_migrations"
-        if Rake::Task.task_defined?(abort_migrations)
-          Rake::Task[abort_migrations].invoke
+        ["db:abort_if_pending_migrations", "app:db:abort_if_pending_migrations"].each do |abort_migrations|
+          if Rake::Task.task_defined?(abort_migrations)
+            Rake::Task[abort_migrations].invoke
+            break
+          end
         end
       end
 
@@ -66,17 +74,17 @@ end
 
 namespace :parallel do
   desc "create test databases via db:create --> parallel:create[num_cpus]"
-  task :create, :count do |t,args|
+  task :create, :count do |_,args|
     ParallelTests::Tasks.run_in_parallel("rake 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 |t,args|
+  task :drop, :count do |_,args|
     ParallelTests::Tasks.run_in_parallel("rake db:drop RAILS_ENV=#{ParallelTests::Tasks.rails_env}", args)
   end
 
   desc "update test databases by dumping and loading --> parallel:prepare[num_cpus]"
-  task(:prepare, [:count]) do |t,args|
+  task(:prepare, [:count]) do |_,args|
     ParallelTests::Tasks.check_for_pending_migrations
     if defined?(ActiveRecord) && ActiveRecord::Base.schema_format == :ruby
       # dump then load in parallel
@@ -85,34 +93,41 @@ namespace :parallel do
     else
       # there is no separate dump / load for schema_format :sql -> do it safe and slow
       args = args.to_hash.merge(:non_parallel => true) # normal merge returns nil
-      ParallelTests::Tasks.run_in_parallel('rake db:test:prepare --trace', args)
+      taskname = Rake::Task.task_defined?('db:test:prepare') ? 'db:test:prepare' : 'app:db:test:prepare'
+      ParallelTests::Tasks.run_in_parallel("rake #{taskname}", args)
     end
   end
 
   # when dumping/resetting takes too long
   desc "update test databases via db:migrate --> parallel:migrate[num_cpus]"
-  task :migrate, :count do |t,args|
+  task :migrate, :count do |_,args|
     ParallelTests::Tasks.run_in_parallel("rake db:migrate 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 |t,args|
-    command = "rake db:schema:load RAILS_ENV=#{ParallelTests::Tasks.rails_env}"
+  task :load_schema, :count do |_,args|
+    command = "rake #{ParallelTests::Tasks.purge_before_load} db:schema:load RAILS_ENV=#{ParallelTests::Tasks.rails_env}"
     ParallelTests::Tasks.run_in_parallel(ParallelTests::Tasks.suppress_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|
+    ParallelTests::Tasks.run_in_parallel("rake #{ParallelTests::Tasks.purge_before_load} db:structure:load RAILS_ENV=#{ParallelTests::Tasks.rails_env}", args)
+  end
+
   desc "load the seed data from db/seeds.rb via db:seed --> parallel:seed[num_cpus]"
-  task :seed, :count do |t,args|
+  task :seed, :count do |_,args|
     ParallelTests::Tasks.run_in_parallel("rake db:seed RAILS_ENV=#{ParallelTests::Tasks.rails_env}", args)
   end
 
   desc "launch given rake command in parallel"
-  task :rake, :command do |t, args|
+  task :rake, :command do |_, args|
     ParallelTests::Tasks.run_in_parallel("RAILS_ENV=#{ParallelTests::Tasks.rails_env} rake #{args.command}")
   end
 
-  ['test', 'spec', 'features'].each do |type|
+  ['test', 'spec', 'features', 'features-spinach'].each do |type|
     desc "run #{type} in parallel with parallel:#{type}[num_cpus]"
     task type, [:count, :pattern, :options] do |t, args|
       ParallelTests::Tasks.check_for_pending_migrations
@@ -124,15 +139,23 @@ namespace :parallel do
       test_framework = {
         'spec' => 'rspec',
         'test' => 'test',
-        'features' => 'cucumber'
+        'features' => 'cucumber',
+        'features-spinach' => 'spinach',
       }[type]
 
+      if test_framework == 'spinach'
+        type = 'features'
+      end
       executable = File.join(File.dirname(__FILE__), '..', '..', 'bin', 'parallel_test')
+
       command = "#{executable} #{type} --type #{test_framework} " \
         "-n #{count} "                     \
         "--pattern '#{pattern}' "          \
         "--test-options '#{options}'"
-
+      if ParallelTests::WINDOWS
+        ruby_binary = File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name'])
+        command = "#{ruby_binary} #{command}"
+      end
       abort unless system(command) # allow to chain tasks e.g. rake parallel:spec parallel:features
     end
   end

data/lib/parallel_tests/test/runner.rb

@@ -1,4 +1,4 @@
-require 'open3'
+require 'parallel_tests'
 
 module ParallelTests
   module Test
@@ -17,7 +17,7 @@ module ParallelTests
         end
 
         def test_suffix
-          "_test.rb"
+          /_(test|spec).rb$/
         end
 
         def test_file_name
@@ -25,12 +25,13 @@ module ParallelTests
         end
 
         def run_tests(test_files, process_number, num_processes, options)
-          require_list = test_files.map { |filename| %{"#{File.expand_path filename}"} }.join(",")
-          cmd = "#{executable} -Itest -e '[#{require_list}].each {|f| require f }' -- #{options[:test_options]}"
+          require_list = test_files.map { |file| file.sub(" ", "\\ ") }.join(" ")
+          cmd = "#{executable} -Itest -e '%w[#{require_list}].each { |f| require %{./\#{f}} }' -- #{options[:test_options]}"
           execute_command(cmd, process_number, num_processes, options)
         end
 
         def line_is_result?(line)
+          line.gsub!(/[.F*]/,'')
           line =~ /\d+ failure/
         end
 
@@ -38,31 +39,59 @@ module ParallelTests
 
         # finds all tests and partitions them into groups
         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
+
+        def tests_with_size(tests, options)
           tests = find_tests(tests, options)
 
-          tests = if options[:group_by] == :found
-            tests.map { |t| [t, 1] }
+          case options[:group_by]
+          when :found
+            tests.map! { |t| [t, 1] }
+          when :filesize
+            sort_by_filesize(tests)
+          when :runtime
+            sort_by_runtime(tests, runtimes(tests, options), options.merge(allowed_missing: 0.5))
+          when nil
+            # use recorded test runtime if we got enough data
+            runtimes = runtimes(tests, options) rescue []
+            if runtimes.size * 1.5 > tests.size
+              puts "Using recorded test runtime"
+              sort_by_runtime(tests, runtimes)
+            else
+              sort_by_filesize(tests)
+            end
           else
-            with_runtime_info(tests)
+            raise ArgumentError, "Unsupported option #{options[:group_by]}"
           end
-          Grouper.in_even_groups_by_size(tests, num_groups, options)
+
+          tests
         end
 
-        def execute_command(cmd, process_number,  num_processes, options)
+        def execute_command(cmd, process_number, num_processes, options)
           env = (options[:env] || {}).merge(
             "TEST_ENV_NUMBER" => test_env_number(process_number, options),
             "PARALLEL_TEST_GROUPS" => num_processes
           )
           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
 
         def execute_command_and_capture_output(env, cmd, silence)
           # make processes descriptive / visible in ps -ef
+          separator = (WINDOWS ? ' & ' : ';')
           exports = env.map do |k,v|
-            "#{k}=#{v};export #{k}"
-          end.join(";")
-          cmd = "#{exports};#{cmd}"
+            if WINDOWS
+              "(SET \"#{k}=#{v}\")"
+            else
+              "#{k}=#{v};export #{k}"
+            end
+          end.join(separator)
+          cmd = "#{exports}#{separator}#{cmd}"
 
           output = open("|#{cmd}", "r") { |output| capture_output(output, silence) }
           exitstatus = $?.exitstatus
@@ -72,7 +101,7 @@ module ParallelTests
 
         def find_results(test_output)
           test_output.split("\n").map {|line|
-            line = line.gsub(/\.|F|\*/,'').gsub(/\e\[\d+m/,'')
+            line.gsub!(/\e\[\d+m/,'')
             next unless line_is_result?(line)
             line
           }.compact
@@ -113,6 +142,9 @@ module ParallelTests
           loop do
             begin
               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
@@ -123,29 +155,49 @@ module ParallelTests
           result
         end
 
-        def with_runtime_info(tests)
-          lines = File.read(runtime_log).split("\n") rescue []
+        def sort_by_runtime(tests, runtimes, options={})
+          allowed_missing = options[:allowed_missing] || 1.0
+          allowed_missing = tests.size * allowed_missing
 
-          # use recorded test runtime if we got enough data
-          if lines.size * 1.5 > tests.size
-            puts "Using recorded test runtime"
-            times = Hash.new(1)
-            lines.each do |line|
-              test, time = line.split(":")
-              next unless test and time
-              times[File.expand_path(test)] = time.to_f
-            end
-            tests.sort.map{|test| [test, times[File.expand_path(test)]] }
-          else # use file sizes
-            tests.sort.map{|test| [test, File.stat(test).size] }
+          # set know runtime for each test
+          tests.sort!
+          tests.map! do |test|
+            allowed_missing -= 1 unless time = runtimes[test]
+            raise "Too little runtime info" if allowed_missing < 0
+            [test, time]
+          end
+
+          if options[:verbose]
+            puts "Runtime found for #{tests.count(&:last)} of #{tests.size} tests"
+          end
+
+          # fill gaps with unknown-runtime if given, average otherwise
+          known, unknown = tests.partition(&:last)
+          average = (known.any? ? known.map!(&:last).inject(:+) / known.size : 1)
+          unknown_runtime = options[:unknown_runtime] || average
+          unknown.each { |set| set[1] = unknown_runtime }
+        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
+            times[test] = time.to_f if tests.include?(test)
           end
         end
 
+        def sort_by_filesize(tests)
+          tests.sort!
+          tests.map! { |test| [test, File.stat(test).size] }
+        end
+
         def find_tests(tests, options = {})
           (tests || []).map do |file_or_folder|
             if File.directory?(file_or_folder)
               files = files_in_folder(file_or_folder, options)
-              files.grep(/#{Regexp.escape test_suffix}$/).grep(options[:pattern]||//)
+              files.grep(options[:suffix]||test_suffix).grep(options[:pattern]||//)
             else
               file_or_folder
             end