parallelized_specs 0.0.5 → 0.0.6

data/Gemfile

@@ -1,10 +0,0 @@
-source :rubygems
-
-gem 'parallel'
-
-group :dev do
-  gem 'test-unit', :platform => :ruby_19
-  gem 'rspec', '>=2.4'
-  gem 'rake'
-  gem 'jeweler'
-end

data/Rakefile

@@ -12,7 +12,7 @@ begin
     gem.email    = "jake@instructure.com"
     gem.homepage = "http://github.com/jakesorce/#{gem.name}"
     gem.authors  = "Jake Sorce, Bryan Madsen"
-    gem.version = "0.0.5"
+    gem.version = "0.0.6"
   end
 
   Jeweler::GemcutterTasks.new

data/VERSION

@@ -1 +1 @@
-0.0.5
+0.0.6

data/bin/parallelized_spec

@@ -1,2 +1,95 @@
 #!/usr/bin/env ruby
-exec "#{File.join(File.dirname(__FILE__), 'parallelized_test')} -t spec #{ARGV * ' '}"
+require 'rubygems'
+require 'optparse'
+require 'parallel'
+raise "please ' gem install parallel '" if Gem::Version.new(Parallel::VERSION) < Gem::Version.new('0.4.2')
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
+require "parallelized_specs"
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = <<BANNER
+Run all tests in parallel, giving each process ENV['TEST_ENV_NUMBER'] ('', '2', '3', ...)
+
+[optional] Only run selected files & folders:
+    parallelized_spec test/bar test/baz/xxx_text_spec.rb
+
+Options are:
+BANNER
+  opts.on("-n [PROCESSES]", Integer, "How many processes to use, default: available CPUs"){|n| options[:count] = n }
+  opts.on("-p", '--pattern [PATTERN]', "run tests matching this pattern"){|pattern| options[:pattern] = pattern }
+  opts.on("--no-sort", "do not sort files before running them"){ |no_sort| options[:no_sort] = no_sort }
+  opts.on("-m [FLOAT]", "--multiply-processes [FLOAT]", Float, "use given number as a multiplier of processes to run"){ |multiply| options[:multiply] = multiply }
+  opts.on("-r", '--root [PATH]', "execute test commands from this path"){|path| options[:root] = path }
+  opts.on("-s [PATTERN]", "--single [PATTERN]", "Run all matching files in only one process") do |pattern|
+    options[:single_process] ||= []
+    options[:single_process] << /#{pattern}/
+  end
+  opts.on("-e", '--exec [COMMAND]', "execute this code parallel and with ENV['TEST_ENV_NUM']"){|path| options[:execute] = path }
+  opts.on("-o", "--test-options '[OPTIONS]'", "execute test commands with those options"){|arg| options[:test_options] = arg }
+  opts.on("-t", "--type [TYPE]", "which type of tests to run? test, spec or features"){|type| options[:type] = type }
+  opts.on("--non-parallel", "execute same commands but do not in parallel, needs --exec"){ options[:non_parallel] = true }
+  opts.on("--chunk-timeout [TIMEOUT]", "timeout before re-printing the output of a child-process"){|timeout| options[:chunk_timeout] = timeout.to_f }
+  opts.on('-v', '--version', 'Show Version'){ puts ParallelizedSpecs::VERSION; exit}
+  opts.on("-h", "--help", "Show this.") { puts opts; exit }
+end.parse!
+
+raise "--no-sort and --single-process are not supported" if options[:no_sort] and options[:single_process]
+
+# get files to run from arguments
+options[:files] = ARGV if ARGV.size > 0
+
+num_processes = options[:count] || Parallel.processor_count
+num_processes = num_processes * (options[:multiply] || 1)
+
+if options[:execute]
+  runs = (0...num_processes).to_a
+  results = if options[:non_parallel]
+    runs.map do |i|
+      ParallelizedSpecs.execute_command(options[:execute], i, options)
+    end
+  else
+    Parallel.map(runs, :in_processes => num_processes) do |i|
+      ParallelizedSpecs.execute_command(options[:execute], i, options)
+    end
+  end.flatten
+  abort if results.any?{|r| r[:exit_status] != 0 }
+else
+  lib, name, task = {
+    'spec' => %w(specs spec spec),
+  }[options[:type]||'spec']
+
+  require "parallelized_#{lib}"
+  klass = eval("Parallelized#{lib.capitalize}")
+
+  start = Time.now
+
+  tests_folder = task
+  tests_folder = File.join(options[:root], tests_folder) unless options[:root].to_s.empty?
+
+  groups = klass.tests_in_groups(options[:files] || tests_folder, num_processes, options)
+  num_processes = groups.size
+
+  #adjust processes to groups
+  abort "no #{name}s found!" if groups.size == 0
+
+  num_tests = groups.inject(0){|sum,item| sum + item.size }
+  puts "#{num_processes} processes for #{num_tests} #{name}s, ~ #{num_tests / groups.size} #{name}s per process"
+
+  test_results = Parallel.map(groups, :in_processes => num_processes) do |group|
+    klass.run_tests(group, groups.index(group), options)
+  end
+
+  #parse and print results
+  results = klass.find_results(test_results.map{|result| result[:stdout] }*"")
+  puts ""
+  puts klass.summarize_results(results)
+
+  #report total time taken
+  puts ""
+  puts "Took #{Time.now - start} seconds"
+
+  #exit with correct status code so rake parallel:test && echo 123 works
+  failed = test_results.any?{|result| result[:exit_status] != 0 }
+  abort "#{name.capitalize}s Failed" if failed
+end

data/lib/parallelized_specs.rb

@@ -1,6 +1,10 @@
-require 'parallelized_tests'
+require 'parallel'
+require 'parallelized_specs/grouper'
+require 'parallelized_specs/railtie'
+
+class ParallelizedSpecs
+  VERSION = File.read(File.join(File.dirname(__FILE__), '..', 'VERSION')).strip
 
-class ParallelizedSpecs < ParallelizedTests
   def self.run_tests(test_files, process_number, options)
     exe = executable # expensive, so we cache
     version = (exe =~ /\brspec\b/ ? 2 : 1)
@@ -10,24 +14,18 @@ class ParallelizedSpecs < ParallelizedTests
 
   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
+            "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/parallelized_profile.log'
-  end
-
   protected
-
-  # so it can be stubbed....
+  #so it can be stubbed....
   def self.run(cmd)
     `#{cmd}`
   end
@@ -41,7 +39,7 @@ class ParallelizedSpecs < ParallelizedTests
   end
 
   def self.spec_opts(rspec_version)
-    options_file = ['spec/parallelized_spec.opts', 'spec/spec.opts'].detect{|f| File.file?(f) }
+    options_file = %w(spec/parallelized_spec.opts spec/spec.opts).detect { |f| File.file?(f) }
     return unless options_file
     "-O #{options_file}"
   end
@@ -49,4 +47,150 @@ class ParallelizedSpecs < ParallelizedTests
   def self.test_suffix
     "_spec.rb"
   end
+
+  # 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]
+      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.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/parallelized_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.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

data/lib/{parallelized_tests → parallelized_specs}/grouper.rb

@@ -1,4 +1,4 @@
-class ParallelizedTests
+class ParallelizedSpecs
   class Grouper
     def self.in_groups(items, num_groups)
       groups = Array.new(num_groups){ [] }

data/lib/{parallelized_tests → parallelized_specs}/railtie.rb

@@ -1,9 +1,9 @@
 # add rake tasks if we are inside Rails
 if defined?(Rails::Railtie)
-  class ParallelizedTests
+  class ParallelizedSpecs
     class Railtie < ::Rails::Railtie
       rake_tasks do
-        load File.expand_path("../../tasks/parallelized_tests.rake", __FILE__)
+        load File.expand_path("../tasks/parallelized_specs.rake", __FILE__)
       end
     end
   end

data/lib/parallelized_specs/runtime_logger.rb

@@ -0,0 +1,26 @@
+class ParallelizedSpecs::RuntimeLogger
+  @@has_started = false
+
+  def self.log(test, start_time, end_time)
+
+    if !@@has_started # make empty log file 
+      File.open(ParallelizedSpecs.runtime_log, 'w') do end
+      @@has_started = true
+    end
+
+    File.open(ParallelizedSpecs.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
+end

data/lib/{parallelized_tests → parallelized_specs}/tasks.rb

@@ -1,23 +1,23 @@
 namespace :parallel do
   def run_in_parallel(cmd, options)
     count = (options[:count] ? options[:count].to_i : nil)
-    executable = File.join(File.dirname(__FILE__), '..', '..', 'bin', 'parallelized_test')
+    executable = File.join(File.dirname(__FILE__), '..', '..', 'bin', 'parallelized_spec')
     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|
+  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|
+  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|
+  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
@@ -31,26 +31,24 @@ namespace :parallel do
 
   # 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 |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|
+  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 "parallelized_tests"
-      count, pattern, options = ParallelizedTests.parse_rake_args(args)
-      executable = File.join(File.dirname(__FILE__), '..', '..', 'bin', 'parallelized_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
+  desc "run spec in parallel with parallel:spec[num_cpus]"
+  task 'spec', :count, :pattern, :options, :arguments do |t, args|
+    $LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), '..'))
+    require "parallelized_specs"
+    count, pattern, options = ParallelizedSpecs.parse_rake_args(args)
+    executable = File.join(File.dirname(__FILE__), '..', '..', 'bin', 'parallelized_spec')
+    command = "#{executable} --type 'spec' -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
 
@@ -60,20 +58,20 @@ end
 #test:parallel
 namespace :spec do
   namespace :parallel do
-    task :prepare, :count do |t,args|
+    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|
+  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|
+  task :parallel, :count, :pattern do |t, args|
     $stderr.puts "WARNING -- Deprecated! use parallel:test"
     Rake::Task['parallel:test'].invoke(args[:count], args[:pattern])
   end