parallelized_specs 0.0.1

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,56 @@
+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
+
+  def dump_summary(*args);end
+
+  def dump_failures(*args);end
+
+  def dump_failure(*args);end
+
+  def dump_pending(*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,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, count, failure)
+    @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_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_tests/grouper.rb

@@ -0,0 +1,49 @@
+class ParallelTests
+  class Grouper
+    def self.in_groups(items, num_groups)
+      groups = Array.new(num_groups){ [] }
+
+      until items.empty?
+        num_groups.times do |group_number|
+          groups[group_number] << items.shift
+        end
+      end
+
+      groups.map!(&:sort!)
+    end
+
+    def self.in_even_groups_by_size(items_with_sizes, num_groups, options={})
+      groups = Array.new(num_groups){{:items => [], :size => 0}}
+
+      # add all files that should run in a single process to one group
+      (options[:single_process]||[]).each do |pattern|
+        matched, items_with_sizes = items_with_sizes.partition{|item, size| item =~ pattern }
+        smallest = smallest_group(groups)
+        matched.each{|item,size| add_to_group(smallest, item, size) }
+      end
+
+      # add all other files
+      largest_first(items_with_sizes).each do |item, size|
+        smallest = smallest_group(groups)
+        add_to_group(smallest, item, size)
+      end
+
+      groups.map!{|g| g[:items].sort }
+    end
+
+    def self.largest_first(files)
+      files.sort_by{|item, size| size }.reverse
+    end
+
+  private
+
+    def self.smallest_group(groups)
+      groups.min_by{|g| g[:size] }
+    end
+
+    def self.add_to_group(group, item, size)
+      group[:items] << item
+      group[:size] += size
+    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/runtime_logger.rb

@@ -0,0 +1,78 @@
+class ParallelTests::RuntimeLogger
+  @@has_started = false
+
+  def self.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(ParallelTests.runtime_log, 'w') do end
+      @@has_started = true
+    end
+
+    File.open(ParallelTests.runtime_log, 'a') do |output|
+      begin
+        output.flock File::LOCK_EX
+        output.puts(self.message(test, start_time, end_time))
+      ensure
+        output.flock File::LOCK_UN
+      end
+    end
+  end
+
+  def self.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"
+    message="#{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 self.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 self.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
+
+end
+
+require 'test/unit/testsuite'
+class Test::Unit::TestSuite
+
+  alias :run_without_timing :run unless defined? @@timing_installed
+
+  def run(result, &progress_block)
+    start_time=Time.now
+    run_without_timing(result, &progress_block)
+    end_time=Time.now
+    ParallelTests::RuntimeLogger.log(self.tests.first, start_time, end_time)
+  end
+  @@timing_installed = true
+
+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, :arguments 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}' #{args[:arguments]}"
+      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