parallelized_specs 0.1.8 → 0.1.9

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.1.8"
+    gem.version = "0.1.9"
   end
 
   Jeweler::GemcutterTasks.new

data/Readme.md

@@ -58,22 +58,20 @@ ParallelizedSpecs uses 1 database per test-process, 2 processes will use `*_test
 ### 4: Run!
     rake parallel:spec          # RSpec
 
-    rake parallel:test[1] --> force 1 CPU --> 86 seconds
-    rake parallel:test    --> got 2 CPUs? --> 47 seconds
-    rake parallel:test    --> got 4 CPUs? --> 26 seconds
+    rake parallel:spec[1] --> force 1 CPU --> 86 seconds
+    rake parallel:spec    --> got 2 CPUs? --> 47 seconds
+    rake parallel:spec    --> got 4 CPUs? --> 26 seconds
     ...
 
 Test by pattern (e.g. use one integration server per subfolder / see if you broke any 'user'-related tests)
 
-    rake parallel:test[^unit] # everything in test/spec folder (every test file matching /^spec/)
-    rake parallel:test[user]  # run users_controller + user_helper + user tests
-    rake parallel:test['user|product']  # run user and product related tests
-
+    rake parallel:spec[4,user,]  # force 4 CPU and run users specs
+    rake parallel:spec['user|product']  # run user and product related specs
 
 Example output
 --------------
     2 processes for 210 specs, ~ 105 specs per process
-    ... test output ...
+    ... spec output ...
 
     843 examples, 0 failures, 1 pending
 
@@ -98,10 +96,6 @@ Rspec: Add to your `spec/parallelized_specs.opts` (or `spec/spec.opts`) :
       --format progress
       --format ParallelizedSpecs::SpecRuntimeLogger --out tmp/parallel_profile.log
 
-Test::Unit:  Add to your `test_helper.rb`:
-    require 'parallelized_specs/runtime_logger'
-
-
 SpecSummaryLogger
 --------------------
 

data/VERSION

@@ -1 +1 @@
-0.1.8
+0.1.9

data/lib/parallelized_specs.rb

@@ -85,181 +85,177 @@ class ParallelizedSpecs
 
     tests_folder = 'spec'
     tests_folder = File.join(options[:root], tests_folder) unless options[:root].to_s.empty?
-    if tests.is_a?(Array)
-      groups = tests_in_groups(tests || tests_folder, num_processes, options)
-    else
+    if !tests.is_a?(Array)
       files_array = tests.split(/ /)
-      groups = tests_in_groups(files_array || tests_folder, num_processes, options)
     end
-    num_processes = groups.size
+    groups = tests_in_groups(files_array || tests || tests_folder, num_processes, options)
 
-    #adjust processes to groups
-    abort "no #{name}s found!" if groups.size == 0
+  num_processes = groups.size
 
-    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"
+  #adjust processes to groups
+  abort "no #{name}s found!" if groups.size == 0
 
-    test_results = Parallel.map(groups, :in_processes => num_processes) do |group|
-      run_tests(group, groups.index(group), options)
-    end
+  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"
 
-    #parse and print results
-    results = find_results(test_results.map { |result| result[:stdout] }*"")
-    puts ""
-    puts summarize_results(results)
+  test_results = Parallel.map(groups, :in_processes => num_processes) do |group|
+    run_tests(group, groups.index(group), options)
+  end
 
-    #report total time taken
-    puts ""
-    puts "Took #{Time.now - start} seconds"
+  #parse and print results
+  results = find_results(test_results.map { |result| result[:stdout] }*"")
+  puts ""
+  puts summarize_results(results)
 
-    #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
+  #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
 
 # 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
+def self.parse_rake_args(args)
+  # order as given by user
+  args = [args[:count], args[:pattern]]
+
+  # count given or empty ?
+  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
+
+  [num_processes.to_i, pattern.to_s]
+end
 
 # finds all tests and partitions them into groups
-  def self.tests_in_groups(tests, num_groups, 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
+def self.tests_in_groups(tests, num_groups, 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.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.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.test_env_number(process_number)
+  process_number == 0 ? '' : process_number + 1
+end
 
-  def self.runtime_log
-    'tmp/parallelized_runtime_test.log'
-  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(', ')
+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
+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
+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
+  # print the remainder
+  print buffer
+  STDOUT.flush
 
-    all
-  end
+  all
+end
 
 # copied from http://github.com/carlhuda/bundler Bundler::SharedHelpers#find_gemfile
-  def self.bundler_enabled?
-    return true if Object.const_defined?(:Bundler)
+def self.bundler_enabled?
+  return true if Object.const_defined?(:Bundler)
 
-    previous = nil
-    current = File.expand_path(Dir.pwd)
+  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
+  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
 
-  def self.line_is_result?(line)
-    line =~ /\d+ failure/
-  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] }
+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| "/#{f}" }
-    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| "/#{f}" }
   end
+end
 
 end

data/lib/parallelized_specs/tasks.rb

@@ -13,19 +13,24 @@ namespace :parallel do
     ParallelizedSpecs.execute_parallel_db('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|
+  desc "update test databases by dumping and loading --> parallel:dump_load[num_cpus]"
+  task(:dump_load, [: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])
+      Rake::Task['parallel:load_schema'].invoke
     else
-      # there is no separate dump / load for schema_format :sql -> do it safe and slow
+      # there is no separate dump / load for s(args[:count])chema_format :sql -> do it safe and slow
       args = args.to_hash.merge(:non_parallel => true) # normal merge returns nil
-      ParallelizedSpecs.execute_parallel_db('rake db:test:prepare --trace', args)
+      ParallelizedSpecs.execute_parallel_db('rake db:test:dump_load', args)
     end
   end
 
+  desc "drop, create, migrate all in one --> parallel:prepare[num_cpus]"
+  task :prepare, :count do |t, args|
+    ParallelizedSpecs.execute_parallel_db('rake db:drop db:create db:migrate RAILS_ENV=test', args)
+  end
+
   # when dumping/resetting takes too long
   desc "update test databases via db:migrate --> parallel:migrate[num_cpus]"
   task :migrate, :count do |t, args|
@@ -40,7 +45,7 @@ namespace :parallel do
 
   desc "run spec in parallel with parallel:spec[num_cpus]"
   task 'spec', :count, :pattern, :options, :arguments do |t, args|
-    count, pattern, options = ParallelizedSpecs.parse_rake_args(args)
+    count, pattern = ParallelizedSpecs.parse_rake_args(args)
     opts = {:count => count, :pattern => pattern, :root => Rails.root, :files => args[:arguments]}
     ParallelizedSpecs.execute_parallel_specs(opts)
   end

data/parallelized_specs.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "parallelized_specs"
-  s.version = "0.1.8"
+  s.version = "0.1.9"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Jake Sorce, Bryan Madsen"]
-  s.date = "2012-05-03"
+  s.date = "2012-05-07"
   s.email = "jake@instructure.com"
   s.files = [
     "Gemfile",
@@ -31,6 +31,7 @@ Gem::Specification.new do |s|
     "lib/parallelized_specs/tasks.rb",
     "lib/tasks/parallelized_specs.rake",
     "parallelized_specs.gemspec",
+    "spec/integration_spec.rb",
     "spec/parallelized_specs/spec_failure_logger_spec.rb",
     "spec/parallelized_specs/spec_runtime_logger_spec.rb",
     "spec/parallelized_specs/spec_summary_logger_spec.rb",

data/spec/integration_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+
+describe 'CLI' do
+  before do
+    `rm -rf #{folder}`
+  end
+
+  after do
+    `rm -rf #{folder}`
+  end
+
+  def folder
+    "/tmp/parallel_tests_tests"
+  end
+
+  def write(file, content)
+    path = "#{folder}/#{file}"
+    `mkdir -p #{File.dirname(path)}` unless File.exist?(File.dirname(path))
+    File.open(path, 'w'){|f| f.write content }
+    path
+  end
+
+  def bin_folder
+    "#{File.expand_path(File.dirname(__FILE__))}/../bin"
+  end
+
+  def executable
+    "#{bin_folder}/parallel_test"
+  end
+
+  def run_tests(options={})
+    `cd #{folder} && #{executable} --chunk-timeout 999 -t #{options[:type] || 'spec'} -n #{options[:processes]||2} #{options[:add]} 2>&1`
+  end
+
+  it "runs tests in parallel" do
+    write 'spec/xxx_spec.rb', 'describe("it"){it("should"){puts "TEST1"}}'
+    write 'spec/xxx2_spec.rb', 'describe("it"){it("should"){puts "TEST2"}}'
+    result = run_tests
+
+    # test ran and gave their puts
+    result.should include('TEST1')
+    result.should include('TEST2')
+
+    # all results present
+    result.scan('1 example, 0 failure').size.should == 2 # 2 results
+    result.scan('2 examples, 0 failures').size.should == 1 # 1 summary
+    result.scan(/Finished in \d+\.\d+ seconds/).size.should == 2
+    result.scan(/Took \d+\.\d+ seconds/).size.should == 1 # parallel summary
+    $?.success?.should == true
+  end
+
+  it "does not run any tests if there are none" do
+    write 'spec/xxx.rb', 'xxx'
+    result = run_tests
+    result.should include('No examples found')
+    result.should include('Took')
+  end
+
+  it "fails when tests fail" do
+    write 'spec/xxx_spec.rb', 'describe("it"){it("should"){puts "TEST1"}}'
+    write 'spec/xxx2_spec.rb', 'describe("it"){it("should"){1.should == 2}}'
+    result = run_tests
+
+    result.scan('1 example, 1 failure').size.should == 1
+    result.scan('1 example, 0 failure').size.should == 1
+    result.scan('2 examples, 1 failure').size.should == 1
+    $?.success?.should == false
+  end
+
+  it "can exec given commands with ENV['TEST_ENV_NUM']" do
+    result = `#{executable} -e 'ruby -e "print ENV[:TEST_ENV_NUMBER.to_s].to_i"' -n 4`
+    result.gsub('"','').split('').sort.should == %w[0 2 3 4]
+  end
+
+  it "can exec given command non-parallel" do
+    result = `#{executable} -e 'ruby -e "sleep(rand(10)/100.0); puts ENV[:TEST_ENV_NUMBER.to_s].inspect"' -n 4 --non-parallel`
+    result.split("\n").should == %w["" "2" "3" "4"]
+  end
+
+  it "exists with success if all sub-processes returned success" do
+    system("#{executable} -e 'cat /dev/null' -n 4").should == true
+  end
+
+  it "exists with failure if any sub-processes returned failure" do
+    system("#{executable} -e 'test -e xxxx' -n 4").should == false
+  end
+
+  it "can run through parallel_spec / parallel_cucumber" do
+    version = `#{executable} -v`
+    `#{bin_folder}/parallel_spec -v`.should == version
+    `#{bin_folder}/parallel_cucumber -v`.should == version
+  end
+
+  it "runs faster with more processes" do
+    2.times{|i|
+      write "spec/xxx#{i}_spec.rb",  'describe("it"){it("should"){sleep 5}}; $stderr.puts ENV["TEST_ENV_NUMBER"]'
+    }
+    t = Time.now
+    run_tests(:processes => 2)
+    expected = 10
+    (Time.now - t).should <= expected
+  end
+
+  it "can can with given files" do
+    write "spec/x1_spec.rb", "puts '111'"
+    write "spec/x2_spec.rb", "puts '222'"
+    write "spec/x3_spec.rb", "puts '333'"
+    result = run_tests(:add => 'spec/x1_spec.rb spec/x3_spec.rb')
+    result.should include('111')
+    result.should include('333')
+    result.should_not include('222')
+  end
+
+  it "can run with test-options" do
+    write "spec/x1_spec.rb", ""
+    write "spec/x2_spec.rb", ""
+    result = run_tests(:add => "--test-options ' --version'", :processes => 2)
+    result.should =~ /\d+\.\d+\.\d+.*\d+\.\d+\.\d+/m # prints version twice
+  end
+
+  it "runs with test::unit" do
+    write "test/x1_test.rb", "require 'test/unit'; class XTest < Test::Unit::TestCase; def test_xxx; end; end"
+    result = run_tests(:type => :test)
+    result.should include('1 test')
+    $?.success?.should == true
+  end
+
+  it "passes test options to test::unit" do
+    write "test/x1_test.rb", "require 'test/unit'; class XTest < Test::Unit::TestCase; def test_xxx; end; end"
+    result = run_tests(:type => :test, :add => '--test-options "-v"')
+    result.should include('test_xxx') # verbose output of every test
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: parallelized_specs
 version: !ruby/object:Gem::Version 
-  hash: 11
+  hash: 9
   prerelease: 
   segments: 
   - 0
   - 1
-  - 8
-  version: 0.1.8
+  - 9
+  version: 0.1.9
 platform: ruby
 authors: 
 - Jake Sorce, Bryan Madsen
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-05-03 00:00:00 Z
+date: 2012-05-07 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: parallel
@@ -59,6 +59,7 @@ files:
 - lib/parallelized_specs/tasks.rb
 - lib/tasks/parallelized_specs.rake
 - parallelized_specs.gemspec
+- spec/integration_spec.rb
 - spec/parallelized_specs/spec_failure_logger_spec.rb
 - spec/parallelized_specs/spec_runtime_logger_spec.rb
 - spec/parallelized_specs/spec_summary_logger_spec.rb