phene-parallel_tests 0.6.2

data/lib/parallel_specs.rb

@@ -0,0 +1,51 @@
+require File.join(File.dirname(__FILE__), '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
+
+  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_failures_logger.rb

@@ -0,0 +1,25 @@
+require 'parallel_specs'
+require File.join(File.dirname(__FILE__), 'spec_logger_base')
+
+class ParallelSpecs::SpecFailuresLogger < ParallelSpecs::SpecLoggerBase
+  def initialize(options, output=nil)
+    super
+    @failed_examples = []
+  end
+
+  def example_failed(example, count, failure)
+    @failed_examples << example
+  end
+
+  def dump_failure(*args)
+    lock_output do
+      @failed_examples.each.with_index do | example, i |
+        spec_file = example.location.scan(/^[^:]+/)[0]
+        spec_file.gsub!(%r(^.*?/spec/), './spec/')
+        @output.puts "#{ParallelSpecs.executable} #{spec_file} -e \"#{example.description}\""
+      end
+    end
+    @output.flush
+  end
+
+end

data/lib/parallel_specs/spec_logger_base.rb

@@ -0,0 +1,72 @@
+require 'parallel_specs'
+
+begin
+  require 'rspec/core/formatters/progress_formatter'
+  base = RSpec::Core::Formatters::ProgressFormatter
+rescue LoadError
+  require 'spec/runner/formatter/progress_bar_formatter'
+  base = Spec::Runner::Formatter::BaseTextFormatter
+end
+ParallelSpecs::SpecLoggerBaseBase = base
+
+class ParallelSpecs::SpecLoggerBase < ParallelSpecs::SpecLoggerBaseBase
+  def initialize(options, output=nil)
+    output ||= options # rspec 2 has output as first argument
+
+    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
+
+    @failed_examples = [] # only needed for rspec 2
+  end
+
+  def example_started(*args)
+  end
+
+  def example_passed(example)
+  end
+
+  def example_pending(*args)
+  end
+
+  def example_failed(*args)
+  end
+
+  def start_dump(*args)
+  end
+
+  def dump_summary(*args)
+  end
+
+  def dump_pending(*args)
+  end
+
+  def dump_failure(*args)
+  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,28 @@
+require 'parallel_specs'
+require File.join(File.dirname(__FILE__), 'spec_logger_base')
+
+class ParallelSpecs::SpecRuntimeLogger < ParallelSpecs::SpecLoggerBase
+  def initialize(options, output=nil)
+    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 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
+      @output.puts @example_times.map { |file, time| "#{file}:#{time > 0 ? time : 0}" }
+    end
+    @output.flush
+  end
+
+end

data/lib/parallel_specs/spec_summary_logger.rb

@@ -0,0 +1,47 @@
+require 'parallel_specs'
+require File.join(File.dirname(__FILE__), 'spec_logger_base')
+
+class ParallelSpecs::SpecSummaryLogger < 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 "#{ @passed_examples.size } examples passed"
+    end
+    @output.flush
+  end
+
+  def dump_failure(*args)
+    lock_output do
+      @output.puts "#{ @failed_examples.size } examples failed:"
+      @failed_examples.each.with_index do | failure, i |
+        @output.puts "#{ i + 1 })"
+        @output.puts failure.header
+        @output.puts failure.exception.to_s
+        failure.exception.backtrace.each do | caller |
+          @output.puts caller
+        end
+        @output.puts ''
+      end
+    end
+    @output.flush
+  end
+
+end

data/lib/parallel_tests.rb

@@ -0,0 +1,160 @@
+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_s.empty? ? Parallel.processor_count : count.to_i)
+
+    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)
+    end
+  end
+
+  def self.run_tests(test_files, process_number, options)
+    require_list = test_files.map { |filename| "\"#{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
+    '__foo__'
+  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(":")
+        times[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

data/lib/parallel_tests/grouper.rb

@@ -0,0 +1,31 @@
+class ParallelTests
+  class Grouper
+    def self.in_groups(items, num_groups)
+      [].tap do |groups|
+        while ! items.empty?
+          (0...num_groups).map do |group_number|
+            groups[group_number] ||= []
+            groups[group_number] << items.shift
+          end
+        end
+      end
+    end
+
+    def self.in_even_groups_by_size(items_with_sizes, num_groups)
+      items_with_size = smallest_first(items_with_sizes)
+      groups = Array.new(num_groups){{:items => [], :size => 0}}
+      items_with_size.each do |item, size|
+        # always add to smallest group
+        smallest = groups.sort_by{|g| g[:size] }.first
+        smallest[:items] << item
+        smallest[:size] += size
+      end
+
+      groups.map{|g| g[:items] }
+    end
+
+    def self.smallest_first(files)
+      files.sort_by{|item, size| size }.reverse
+    end
+  end
+end

data/lib/parallel_tests/railtie.rb

@@ -0,0 +1,10 @@
+# add rake tasks if we are inside Rails
+if defined?(Rails::Railtie)
+  class ParallelTests
+    class Railtie < ::Rails::Railtie
+      rake_tasks do
+        load File.expand_path("../../tasks/parallel_tests.rake", __FILE__)
+      end
+    end
+  end
+end

data/lib/parallel_tests/tasks.rb

@@ -0,0 +1,80 @@
+namespace :parallel do
+  def run_in_parallel(cmd, options)
+    count = (options[:count] ? options[:count].to_i : nil)
+    executable = File.join(File.dirname(__FILE__), '..', '..', 'bin', 'parallel_test')
+    command = "#{executable} --exec '#{cmd}' -n #{count} #{'--non-parallel' if options[:non_parallel]}"
+    abort unless system(command)
+  end
+
+  desc "create test databases via db:create --> parallel:create[num_cpus]"
+  task :create, :count do |t,args|
+    run_in_parallel('rake db:create RAILS_ENV=test', args)
+  end
+
+  desc "drop test databases via db:drop --> parallel:drop[num_cpus]"
+  task :drop, :count do |t,args|
+    run_in_parallel('rake db:drop RAILS_ENV=test', args)
+  end
+
+  desc "update test databases by dumping and loading --> parallel:prepare[num_cpus]"
+  task(:prepare, [:count] => 'db:abort_if_pending_migrations') do |t,args|
+    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
+      run_in_parallel('rake db:test:prepare --trace', 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|
+    run_in_parallel('rake db:migrate RAILS_ENV=test', 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|
+    run_in_parallel('rake db:test:load', args)
+  end
+
+  ['test', 'spec', 'features'].each do |type|
+    desc "run #{type} in parallel with parallel:#{type}[num_cpus]"
+    task type, :count, :pattern, :options do |t,args|
+      $LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), '..'))
+      require "parallel_tests"
+      count, pattern, options = ParallelTests.parse_rake_args(args)
+      executable = File.join(File.dirname(__FILE__), '..', '..', 'bin', 'parallel_test')
+      command = "#{executable} --type #{type} -n #{count} -p '#{pattern}' -r '#{Rails.root}' -o '#{options}'"
+      abort unless system(command) # allow to chain tasks e.g. rake parallel:spec parallel:features
+    end
+  end
+end
+
+#backwards compatability
+#spec:parallel:prepare
+#spec:parallel
+#test:parallel
+namespace :spec do
+  namespace :parallel do
+    task :prepare, :count do |t,args|
+      $stderr.puts "WARNING -- Deprecated!  use parallel:prepare"
+      Rake::Task['parallel:prepare'].invoke(args[:count])
+    end
+  end
+
+  task :parallel, :count, :pattern do |t,args|
+    $stderr.puts "WARNING -- Deprecated! use parallel:spec"
+    Rake::Task['parallel:spec'].invoke(args[:count], args[:pattern])
+  end
+end
+
+namespace :test do
+  task :parallel, :count, :pattern do |t,args|
+    $stderr.puts "WARNING -- Deprecated! use parallel:test"
+    Rake::Task['parallel:test'].invoke(args[:count], args[:pattern])
+  end
+end