parallel_tests 1.1.0 → 1.1.1

data/lib/parallel_tests/rspec/summary_logger.rb

@@ -0,0 +1,19 @@
+require 'parallel_tests/rspec/failures_logger'
+
+class ParallelTests::RSpec::SummaryLogger < ParallelTests::RSpec::LoggerBase
+  if RSPEC_3
+    RSpec::Core::Formatters.register self, :dump_failures
+  end
+
+  if RSPEC_1
+    def dump_failure(*args)
+      lock_output { super }
+      @output.flush
+    end
+  else
+    def dump_failures(*args)
+      lock_output { super }
+      @output.flush
+    end
+  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

@@ -0,0 +1,157 @@
+require 'rake'
+
+module ParallelTests
+  module Tasks
+    class << self
+      def rails_env
+        ENV['RAILS_ENV'] || 'test'
+      end
+
+      def run_in_parallel(cmd, options={})
+        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]}"
+        abort unless system(command)
+      end
+
+      # this is a crazy-complex solution for a very simple problem:
+      # removing certain lines from the output without chaning the exit-status
+      # normally I'd not do this, but it has been lots of fun and a great learning experience :)
+      #
+      # - sed does not support | without -r
+      # - grep changes 0 exitstatus to 1 if nothing matches
+      # - sed changes 1 exitstatus to 0
+      # - 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 = %Q{(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}'"'"'}
+        else
+          command
+        end
+      end
+
+      def check_for_pending_migrations
+        ["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
+
+      # parallel:spec[:count, :pattern, :options]
+      def parse_args(args)
+        # order as given by user
+        args = [args[:count], args[:pattern], args[:options]]
+
+        # count given or empty ?
+        # 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?
+        pattern = args.shift
+        options = args.shift
+
+        [num_processes, pattern.to_s, options.to_s]
+      end
+    end
+  end
+end
+
+namespace :parallel do
+  desc "create test databases via db:create --> parallel:create[num_cpus]"
+  task :create, :count do |t,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|
+    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|
+    ParallelTests::Tasks.check_for_pending_migrations
+    if defined?(ActiveRecord) && ActiveRecord::Base.schema_format == :ruby
+      # dump then load in parallel
+      Rake::Task['db:schema:dump'].invoke
+      Rake::Task['parallel:load_schema'].invoke(args[:count])
+    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
+      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|
+    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}"
+    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 |t,args|
+    ParallelTests::Tasks.run_in_parallel("rake 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|
+    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|
+    ParallelTests::Tasks.run_in_parallel("RAILS_ENV=#{ParallelTests::Tasks.rails_env} rake #{args.command}")
+  end
+
+  ['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
+
+      $LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), '..'))
+      require "parallel_tests"
+
+      count, pattern, options = ParallelTests::Tasks.parse_args(args)
+      test_framework = {
+        'spec' => 'rspec',
+        'test' => 'test',
+        '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
+end

data/lib/parallel_tests/test/runner.rb

@@ -0,0 +1,187 @@
+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
+
+        def test_suffix
+          /_(test|spec).rb$/
+        end
+
+        def test_file_name
+          "test"
+        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]}"
+          execute_command(cmd, process_number, num_processes, options)
+        end
+
+        def line_is_result?(line)
+          line.gsub!(/[.F*]/,'')
+          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={})
+          tests = find_tests(tests, options)
+
+          tests = if options[:group_by] == :found
+            tests.map { |t| [t, 1] }
+          elsif options[:group_by] == :filesize
+            with_filesize_info(tests)
+          else
+            with_runtime_info(tests, options)
+          end
+          Grouper.in_even_groups_by_size(tests, num_groups, options)
+        end
+
+        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
+          )
+          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|
+            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
+
+          {:stdout => output, :exit_status => exitstatus}
+        end
+
+        def find_results(test_output)
+          test_output.split("\n").map {|line|
+            line.gsub!(/\e\[\d+m/,'')
+            next unless line_is_result?(line)
+            line
+          }.compact
+        end
+
+        def test_env_number(process_number)
+          process_number == 0 ? '' : process_number + 1
+        end
+
+        def summarize_results(results)
+          sums = sum_up_results(results)
+          sums.sort.map{|word, number|  "#{number} #{word}#{'s' if number != 1}" }.join(', ')
+        end
+
+        protected
+
+        def executable
+          ENV['PARALLEL_TESTS_EXECUTABLE'] || determine_executable
+        end
+
+        def determine_executable
+          "ruby"
+        end
+
+        def sum_up_results(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)|
+            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
+              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
+                $stdout.flush
+              end
+            end
+          end rescue EOFError
+          result
+        end
+
+        def with_runtime_info(tests, options = {})
+          log = options[:runtime_log] || runtime_log
+          lines = File.read(log).split("\n") rescue []
+
+          # use recorded test runtime if we got enough data
+          if lines.size * 1.5 > tests.size
+            puts "Using recorded test runtime: #{log}"
+            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
+            with_filesize_info(tests)
+          end
+        end
+
+        def with_filesize_info(tests)
+          # use filesize to group files
+          tests.sort.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(test_suffix).grep(options[:pattern]||//)
+            else
+              file_or_folder
+            end
+          end.flatten.uniq
+        end
+
+        def files_in_folder(folder, options={})
+          pattern = if options[:symlinks] == false # not nil or true
+            "**/*"
+          else
+            # follow one symlink and direct children
+            # http://stackoverflow.com/questions/357754/can-i-traverse-symlinked-directories-in-ruby-with-a-glob
+            "**{,/*/**}/*"
+          end
+          Dir[File.join(folder, pattern)].uniq
+        end
+      end
+    end
+  end
+end

data/lib/parallel_tests/test/runtime_logger.rb

@@ -0,0 +1,98 @@
+require 'parallel_tests'
+require 'parallel_tests/test/runner'
+
+module ParallelTests
+  module Test
+    class RuntimeLogger
+      @@has_started = false
+
+      class << self
+        def log(test, start_time, end_time)
+          return if test.is_a? ::Test::Unit::TestSuite # don't log for suites-of-suites
+
+          if !@@has_started # make empty log file
+            File.open(logfile, 'w'){}
+            @@has_started = true
+          end
+
+          locked_appending_to(logfile) do |file|
+            file.puts(message(test, start_time, end_time))
+          end
+        end
+
+        private
+
+        def message(test, start_time, end_time)
+          delta = "%.2f" % (end_time.to_f-start_time.to_f)
+          filename = class_directory(test.class) + class_to_filename(test.class) + ".rb"
+          "#{filename}:#{delta}"
+        end
+
+        # Note: this is a best guess at conventional test directory structure, and may need
+        # tweaking / post-processing to match correctly for any given project
+        def class_directory(suspect)
+          result = "test/"
+
+          if defined?(Rails)
+            result += case suspect.superclass.name
+            when "ActionDispatch::IntegrationTest"
+              "integration/"
+            when "ActionDispatch::PerformanceTest"
+              "performance/"
+            when "ActionController::TestCase"
+              "functional/"
+            when "ActionView::TestCase"
+              "unit/helpers/"
+            else
+              "unit/"
+            end
+          end
+          result
+        end
+
+        # based on https://github.com/grosser/single_test/blob/master/lib/single_test.rb#L117
+        def class_to_filename(suspect)
+          word = suspect.to_s.dup
+          return word unless word.match /^[A-Z]/ and not word.match %r{/[a-z]}
+
+          word.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+          word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+          word.gsub!(/\:\:/, '/')
+          word.tr!("-", "_")
+          word.downcase!
+          word
+        end
+
+        def locked_appending_to(file)
+          File.open(file, 'a') do |f|
+            begin
+              f.flock File::LOCK_EX
+              yield f
+            ensure
+              f.flock File::LOCK_UN
+            end
+          end
+        end
+
+        def logfile
+          ParallelTests::Test::Runner.runtime_log
+        end
+      end
+    end
+  end
+end
+
+require 'test/unit/testsuite'
+class ::Test::Unit::TestSuite
+  alias :run_without_timing :run unless defined? @@timing_installed
+
+  def run(result, &progress_block)
+    first_test = self.tests.first
+    start_time = ParallelTests.now
+    run_without_timing(result, &progress_block)
+    end_time = ParallelTests.now
+    ParallelTests::Test::RuntimeLogger.log(first_test, start_time, end_time)
+  end
+
+  @@timing_installed = true
+end