parallel_tests-instructure 0.6.16

data/lib/parallel_cucumber/runtime_logger.rb

@@ -0,0 +1,57 @@
+class ParallelCucumber
+  class RuntimeLogger
+
+    def initialize(step_mother, path_or_io, options=nil)
+      @io = prepare_io(path_or_io)
+      @example_times = Hash.new(0)
+    end
+
+    def before_feature(_)
+      @start_at = Time.now.to_f
+    end
+
+    def after_feature(feature)
+      @example_times[feature.file] += Time.now.to_f - @start_at
+    end
+
+    def after_features(*args)
+      lock_output do
+        @io.puts @example_times.map { |file, time| "#{file}:#{time}" }
+      end
+    end
+
+    private
+
+    def prepare_io(path_or_io)
+      if path_or_io.respond_to?(:write)
+        path_or_io
+      else # its a path
+        File.open(path_or_io, 'w').close # clean out the file
+        file = File.open(path_or_io, 'a')
+
+        at_exit do
+          unless file.closed?
+            file.flush
+            file.close
+          end
+        end
+
+        file
+      end
+    end
+
+    # do not let multiple processes get in each others way
+    def lock_output
+      if File === @io
+        begin
+          @io.flock File::LOCK_EX
+          yield
+        ensure
+          @io.flock File::LOCK_UN
+        end
+      else
+        yield
+      end
+    end
+  end
+end

data/lib/parallel_specs.rb

@@ -0,0 +1,52 @@
+require 'parallel_tests'
+
+class ParallelSpecs < ParallelTests
+  def self.run_tests(test_files, process_number, options)
+    exe = executable # expensive, so we cache
+    version = (exe =~ /\brspec\b/ ? 2 : 1)
+    cmd = "#{rspec_1_color if version == 1}#{exe} #{options[:test_options]} #{rspec_2_color if version == 2}#{spec_opts(version)} #{test_files*' '}"
+    execute_command(cmd, process_number, options)
+  end
+
+  def self.executable
+    cmd = if File.file?("script/spec")
+      "script/spec"
+    elsif bundler_enabled?
+      cmd = (run("bundle show rspec") =~ %r{/rspec-1[^/]+$} ? "spec" : "rspec")
+      "bundle exec #{cmd}"
+    else
+      %w[spec rspec].detect{|cmd| system "#{cmd} --version > /dev/null 2>&1" }
+    end
+    cmd or raise("Can't find executables rspec or spec")
+  end
+
+  # legacy <-> people log to this file using rspec options
+  def self.runtime_log
+    'tmp/parallel_profile.log'
+  end
+
+  protected
+
+  # so it can be stubbed....
+  def self.run(cmd)
+    `#{cmd}`
+  end
+
+  def self.rspec_1_color
+    'RSPEC_COLOR=1 ; export RSPEC_COLOR ;' if $stdout.tty?
+  end
+
+  def self.rspec_2_color
+    '--color --tty ' if $stdout.tty?
+  end
+
+  def self.spec_opts(rspec_version)
+    options_file = ['spec/parallel_spec.opts', 'spec/spec.opts'].detect{|f| File.file?(f) }
+    return unless options_file
+    "-O #{options_file}"
+  end
+
+  def self.test_suffix
+    "_spec.rb"
+  end
+end

data/lib/parallel_specs/spec_error_count_logger.rb

@@ -0,0 +1,30 @@
+require 'parallel_specs'
+require File.join(File.dirname(__FILE__), 'spec_logger_base')
+
+class ParallelSpecs::SpecErrorCountLogger < ParallelSpecs::SpecLoggerBase
+  def initialize(options, output=nil)
+    super
+    @passed_examples = []
+    @pending_examples = []
+    @failed_examples = []
+  end
+
+  def example_passed(example)
+    @passed_examples << example
+  end
+
+  def example_pending(*args)
+    @pending_examples << args
+  end
+
+  def example_failed(example, count, failure)
+    @failed_examples << failure
+  end
+
+  def dump_summary(duration, example_count, failure_count, pending_count)
+    lock_output do
+      @output.puts "#{ @failed_examples.size }"
+    end
+    @output.flush
+  end
+end

data/lib/parallel_specs/spec_error_logger.rb

@@ -0,0 +1,45 @@
+require 'parallel_specs'
+require File.join(File.dirname(__FILE__), 'spec_logger_base')
+
+class ParallelSpecs::SpecErrorLogger < ParallelSpecs::SpecLoggerBase
+  def initialize(options, output=nil)
+    super
+    @passed_examples = []
+    @pending_examples = []
+    @failed_examples = []
+  end
+
+  def example_passed(example)
+    @passed_examples << example
+  end
+
+  def example_pending(*args)
+    @pending_examples << args
+  end
+
+  def example_failed(example, count, failure)
+    @failed_examples << failure
+  end
+
+  def dump_summary(duration, example_count, failure_count, pending_count)
+    lock_output do
+      env_test_number = ENV['TEST_ENV_NUMBER']
+      env_test_number = 1 if ENV['TEST_ENV_NUMBER'].blank?
+      @output.puts ""
+      @output.puts ""
+      @output.puts "FOR TEST EXECUTOR #{env_test_number}: #{@failed_examples.size} failed, #{@passed_examples.size} passed:"
+      @failed_examples.each.with_index do | failure, i |
+        @output.puts ""
+        @output.puts "#{ i + 1 })"
+        @output.puts failure.header
+        unless failure.exception.nil?
+          @output.puts failure.exception.to_s
+          failure.exception.backtrace.each do | caller |
+            @output.puts caller
+          end
+        end
+      end
+    end
+    @output.flush
+  end
+end

data/lib/parallel_specs/spec_failures_logger.rb

@@ -0,0 +1,43 @@
+require 'parallel_specs/spec_logger_base'
+
+class ParallelSpecs::SpecFailuresLogger < ParallelSpecs::SpecLoggerBase
+  # 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
+
+  # RSpec 1: dumps 1 failed spec
+  def dump_failure(*args)
+  end
+
+  # RSpec 2: dumps all failed specs
+  def dump_failures(*args)
+  end
+
+  def dump_summary(*args)
+    lock_output do
+      if RSPEC_1
+        dump_commands_to_rerun_failed_examples_rspec_1
+      else
+        dump_commands_to_rerun_failed_examples
+      end
+    end
+    @output.flush
+  end
+
+  private
+
+  def dump_commands_to_rerun_failed_examples_rspec_1
+    (@failed_examples||[]).each do |example|
+      file, line = example.location.to_s.split(':')
+      next unless file and line
+      file.gsub!(%r(^.*?/spec/), './spec/')
+      @output.puts "#{ParallelSpecs.executable} #{file}:#{line} # #{example.description}"
+    end
+  end
+end

data/lib/parallel_specs/spec_logger_base.rb

@@ -0,0 +1,48 @@
+require 'parallel_specs'
+
+begin
+  require 'rspec/core/formatters/base_text_formatter'
+  base = RSpec::Core::Formatters::BaseTextFormatter
+rescue LoadError
+  require 'spec/runner/formatter/base_text_formatter'
+  base = Spec::Runner::Formatter::BaseTextFormatter
+end
+ParallelSpecs::SpecLoggerBaseBase = base
+
+class ParallelSpecs::SpecLoggerBase < ParallelSpecs::SpecLoggerBaseBase
+  RSPEC_1 = !defined?(RSpec::Core::Formatters::BaseTextFormatter) # do not test for Spec, this will trigger deprecation warning in rspec 2
+
+  def initialize(*args)
+    super
+
+    @output ||= args[1] || args[0] # rspec 1 has output as second argument
+
+    if String === @output # a path ?
+      FileUtils.mkdir_p(File.dirname(@output))
+      File.open(@output, 'w'){} # overwrite previous results
+      @output = File.open(@output, 'a')
+    elsif File === @output # close and restart in append mode
+      @output.close
+      @output = File.open(@output.path, 'a')
+    end
+  end
+
+  #stolen from Rspec
+  def close
+    @output.close  if (IO === @output) & (@output != $stdout)
+  end
+
+  # do not let multiple processes get in each others way
+  def lock_output
+    if File === @output
+      begin
+        @output.flock File::LOCK_EX
+        yield
+      ensure
+        @output.flock File::LOCK_UN
+      end
+    else
+      yield
+    end
+  end
+end

data/lib/parallel_specs/spec_runtime_logger.rb

@@ -0,0 +1,34 @@
+require 'parallel_specs/spec_logger_base'
+
+class ParallelSpecs::SpecRuntimeLogger < ParallelSpecs::SpecLoggerBase
+  def initialize(*args)
+    super
+    @example_times = Hash.new(0)
+  end
+
+  def example_started(*args)
+    @time = Time.now
+  end
+
+  def example_passed(example)
+    file = example.location.split(':').first
+    @example_times[file] += Time.now - @time
+  end
+
+  def dump_summary(*args);end
+  def dump_failures(*args);end
+  def dump_failure(*args);end
+  def dump_pending(*args);end
+
+  def start_dump(*args)
+    return unless ENV['TEST_ENV_NUMBER'] #only record when running in parallel
+    # 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}\//,'')
+        @output.puts "#{relative_path}:#{time > 0 ? time : 0}"
+      end
+    end
+    @output.flush
+  end
+end

data/lib/parallel_specs/spec_start_finish_logger.rb

@@ -0,0 +1,38 @@
+require 'parallel_specs'
+require File.join(File.dirname(__FILE__), 'spec_logger_base')
+
+class ParallelSpecs::SpecStartFinishLogger < ParallelSpecs::SpecLoggerBase
+  def initialize(options, output=nil)
+    output ||= options # rspec 2 has output as first argument
+
+    output = "#{output}_#{ENV['TEST_ENV_NUMBER']}.log"
+    if String === output
+      FileUtils.mkdir_p(File.dirname(output))
+      File.open(output, 'w'){} # overwrite previous results
+      @output = File.open(output, 'a')
+    elsif File === output
+      output.close # close file opened with 'w'
+      @output = File.open(output.path, 'a')
+    else
+      @output = output
+    end
+  end
+
+  def example_started(example)
+    @output.puts ""
+    @output.puts "started spec: #{example.description}"
+  end
+
+  def example_passed(example)
+    @output.puts "finished spec: #{example.description}"
+  end
+
+  def example_pending(example, message)
+    @output.puts "finished spec: #{example.description}"
+  end
+
+  def example_failed(example)
+    @output.puts "finished spec: #{example.description}"
+  end
+
+end

data/lib/parallel_specs/spec_summary_logger.rb

@@ -0,0 +1,19 @@
+require 'parallel_specs/spec_failures_logger'
+
+class ParallelSpecs::SpecSummaryLogger < ParallelSpecs::SpecLoggerBase
+  # RSpec 1: dumps 1 failed spec
+  def dump_failure(*args)
+    lock_output do
+      super
+    end
+    @output.flush
+  end
+
+  # RSpec 2: dumps all failed specs
+  def dump_failures(*args)
+    lock_output do
+      super
+    end
+    @output.flush
+  end
+end

data/lib/parallel_tests.rb

@@ -0,0 +1,163 @@
+require 'parallel'
+require 'parallel_tests/grouper'
+require 'parallel_tests/railtie'
+
+class ParallelTests
+  VERSION = File.read( File.join(File.dirname(__FILE__),'..','VERSION') ).strip
+
+  # parallel:spec[:count, :pattern, :options]
+  def self.parse_rake_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?
+    num_processes ||= ENV['PARALLEL_TEST_PROCESSORS'].to_i if ENV['PARALLEL_TEST_PROCESSORS']
+    num_processes ||= Parallel.processor_count
+
+    pattern = args.shift
+    options = args.shift
+
+    [num_processes.to_i, pattern.to_s, options.to_s]
+  end
+
+  # finds all tests and partitions them into groups
+  def self.tests_in_groups(root, num_groups, options={})
+    tests = find_tests(root, options)
+    if options[:no_sort] == true
+      Grouper.in_groups(tests, num_groups)
+    else
+      tests = with_runtime_info(tests)
+      Grouper.in_even_groups_by_size(tests, num_groups, options)
+    end
+  end
+
+  def self.run_tests(test_files, process_number, options)
+    require_list = test_files.map { |filename| %{"#{File.expand_path filename}"} }.join(",")
+    cmd = "ruby -Itest -e '[#{require_list}].each {|f| require f }' -- #{options[:test_options]}"
+    execute_command(cmd, process_number, options)
+  end
+
+  def self.execute_command(cmd, process_number, options)
+    cmd = "TEST_ENV_NUMBER=#{test_env_number(process_number)} ; export TEST_ENV_NUMBER; #{cmd}"
+    f = open("|#{cmd}", 'r')
+    output = fetch_output(f, options)
+    f.close
+    {:stdout => output, :exit_status => $?.exitstatus}
+  end
+
+  def self.find_results(test_output)
+    test_output.split("\n").map {|line|
+      line = line.gsub(/\.|F|\*/,'')
+      next unless line_is_result?(line)
+      line
+    }.compact
+  end
+
+  def self.test_env_number(process_number)
+    process_number == 0 ? '' : process_number + 1
+  end
+
+  def self.runtime_log
+    'tmp/parallel_runtime_test.log'
+  end
+
+  def self.summarize_results(results)
+    results = results.join(' ').gsub(/s\b/,'') # combine and singularize results
+    counts = results.scan(/(\d+) (\w+)/)
+    sums = counts.inject(Hash.new(0)) do |sum, (number, word)|
+      sum[word] += number.to_i
+      sum
+    end
+    sums.sort.map{|word, number|  "#{number} #{word}#{'s' if number != 1}" }.join(', ')
+  end
+
+  protected
+
+  # read output of the process and print in in chucks
+  def self.fetch_output(process, options)
+    all = ''
+    buffer = ''
+    timeout = options[:chunk_timeout] || 0.2
+    flushed = Time.now.to_f
+
+    while char = process.getc
+      char = (char.is_a?(Fixnum) ? char.chr : char) # 1.8 <-> 1.9
+      all << char
+
+      # print in chunks so large blocks stay together
+      now = Time.now.to_f
+      buffer << char
+      if flushed + timeout < now
+        print buffer
+        STDOUT.flush
+        buffer = ''
+        flushed = now
+      end
+    end
+
+    # print the remainder
+    print buffer
+    STDOUT.flush
+
+    all
+  end
+
+  # copied from http://github.com/carlhuda/bundler Bundler::SharedHelpers#find_gemfile
+  def self.bundler_enabled?
+    return true if Object.const_defined?(:Bundler)
+
+    previous = nil
+    current = File.expand_path(Dir.pwd)
+
+    until !File.directory?(current) || current == previous
+      filename = File.join(current, "Gemfile")
+      return true if File.exists?(filename)
+      current, previous = File.expand_path("..", current), current
+    end
+
+    false
+  end
+
+  def self.line_is_result?(line)
+    line =~ /\d+ failure/
+  end
+
+  def self.test_suffix
+    "_test.rb"
+  end
+
+  def self.with_runtime_info(tests)
+    lines = File.read(runtime_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"
+      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[test]] }
+    else # use file sizes
+      tests.sort.map{|test| [test, File.stat(test).size] }
+    end
+  end
+
+  def self.find_tests(root, options={})
+    if root.is_a?(Array)
+      root
+    else
+      # follow one symlink and direct children
+      # http://stackoverflow.com/questions/357754/can-i-traverse-symlinked-directories-in-ruby-with-a-glob
+      files = Dir["#{root}/**{,/*/**}/*#{test_suffix}"].uniq
+      files = files.map{|f| f.sub(root+'/','') }
+      files = files.grep(/#{options[:pattern]}/)
+      files.map{|f| "#{root}/#{f}" }
+    end
+  end
+end