parallelized_specs 0.3.23 → 0.3.24

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, Shawn Meredith"
-    gem.version = "0.3.23"
+    gem.version = "0.3.24"
   end
   Jeweler::GemcutterTasks.new
 rescue LoadError

data/lib/parallelized_specs.rb

@@ -95,172 +95,221 @@ class ParallelizedSpecs
     end
     groups = tests_in_groups(files_array || tests || tests_folder, num_processes, options)
 
-  num_processes = groups.size
+    num_processes = groups.size
 
-  #adjust processes to groups
-  abort "no #{name}s found!" if groups.size == 0
+    #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"
+    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|
-    run_tests(group, groups.index(group), options)
-  end
+    test_results = Parallel.map(groups, :in_processes => num_processes) do |group|
+      run_tests(group, groups.index(group), options)
+    end
 
-  #parse and print results
-  results = find_results(test_results.map { |result| result[:stdout] }*"")
-  puts ""
-  puts summarize_results(results)
+    #parse and print results
+    results = find_results(test_results.map { |result| result[:stdout] }*"")
+    puts ""
+    puts summarize_results(results)
 
-  #report total time taken
-  puts ""
-  puts "Took #{Time.now - start} seconds"
+    #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
+    #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]]
+  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
+    # 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
+    pattern = args.shift
 
-  [num_processes.to_i, pattern.to_s]
-end
+    [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)
+  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
-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
+
+  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
-  sums.sort.map { |word, number| "#{number} #{word}#{'s' if number != 1}" }.join(', ')
-end
 
-protected
+  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
 
-# 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
+  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
 
-  # print the remainder
-  print buffer
-  STDOUT.flush
+  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
+    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
+    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
+    false
+  end
 
-def self.line_is_result?(line)
-  line =~ /\d+ failure/
-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 []
+  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
 
-  # 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
+  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
-    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}" }
+
+  def self.rerun()
+    rerun_failed_examples = false
+
+    if FileTest.exist?("#{RAILS_ROOT}/tmp/parallel_log/rspec.failures")
+      @error_count = %x{wc -l "#{FILENAME}"}.match(/\d/).to_s #counts the number of lines in the file
+
+      if @error_count.to_i > 1 && @error_count.to_i < 10
+        puts "rerunning #{@error_count} examples again"
+        @rerun_failures ||= []
+        @rerun_passes ||= []
+
+        File.open("#{FILENAME}").each_line do |l|
+          rerun_failed_examples = true
+          puts "#{l} will be ran and marked as a success if it passes"
+          result = %x[bundle exec rake spec #{l}]
+          rerun_status = result.match(/FAILED/).to_s
+
+          if rerun_status == "FAILED"
+            puts "the example failed again"
+            @rerun_failures << l
+            rerun_status = ""
+          else
+            puts "the example passed and is being marked as a success"
+            @rerun_passes << l
+            rerun_status = ""
+          end
+        end #end file loop
+      end
+
+      if rerun_failed_examples
+        if @rerun_failures.count > 0
+          puts "1 or more examples failed on rerun, rspec will mark this build as a failure"
+          #dump errors to file
+          exit(1)
+        elsif @rerun_passes.count >= @error_count.to_i
+          puts "all rerun examples passed, rspec will mark this build as passed"
+          $rerun_success = true
+          exit(0)
+        else
+          put "something unexpected happened not safe to mark the build as passed."
+          exit(1)
+        end
+      end
+    end
+    else
+      "No errors file was found, marking build as a success"
+      exit(0)
+    end
   end
-end
 
-end

data/lib/parallelized_specs/example_failures_logger.rb

@@ -7,7 +7,7 @@ class ParallelizedSpecs::ExampleRerunFailuresLogger < ParallelizedSpecs::SpecLog
       if example.location != nil
         unless !!self.example_group.nested_descriptions.to_s.match(/shared/) || !!self.instance_variable_get(:@example_group).examples.last.location.match(/helper/)
           @failed_examples ||= []
-          @failed_examples << "#{example.location.match(/spec.*\d/).to_s.chomp}"
+          @failed_examples << "#{example.location.match(/spec.*\d/).to_s.chomp} "
         end
       end
       else

data/lib/parallelized_specs/failures_rerun_logger.rb

@@ -3,9 +3,7 @@ require 'parallelized_specs/spec_logger_base'
 
 module RSpec
   class ParallelizedSpecs::FailuresFormatter < ParallelizedSpecs::SpecLoggerBase
-    #env_test_number = ENV['TEST_ENV_NUMBER']
-    #env_test_number = 1 if ENV['TEST_ENV_NUMBER'].nil
-    FILENAME = "#{RAILS_ROOT}/rspec.failures"
+    FILENAME = "#{RAILS_ROOT}/tmp/parallel_log/rspec.failures"
 
     def example_failed(example, counter, failure)
       @rerun_examples ||= []
@@ -15,41 +13,6 @@ module RSpec
     end
 
     def dump_summary(*args)
-      rerun_failed_examples = false
-      @rerun_failures ||= []
-      @rerun_passes ||= []
-      @error_count = %x{wc -l "#{FILENAME}"}.match(/\d/).to_s #counts the number of lines in the file
-
-      if @error_count.to_i > 1 && @error_count.to_i < 10
-        @output.puts "rerunning #{@error_count} examples again"
-        File.open("#{FILENAME}").each_line do |l|
-          rerun_failed_examples = true
-          @output.puts "#{l} will be ran and marked as a success if it passes"
-          result = %x[bundle exec rake spec #{l}]
-          rerun_status = result.match(/FAILED/).to_s
-
-          if rerun_status == "FAILED"
-            @output.puts "the example failed again"
-            @rerun_failures << l
-            rerun_status = ""
-          else
-            @output.puts "the example passed and is being marked as a success"
-            @rerun_passes << l
-            rerun_status = ""
-          end
-        end #end file loop
-      end
-
-      if rerun_failed_examples
-        if @rerun_failures.length > 0
-          @output.puts "1 or more examples failed on rerun, rspec will mark this build as a failure"
-        else
-          @output.puts "all rerun examples passed, rspec will mark this build as passed"
-          $rerun_success = true
-          Spec::Runner.options.instance_variable_get(:@reporter).instance_variable_get(:@failures).delete_if { |item| item != 'b' } #placeholder delete all failures in array approach
-        end
-      else
-      end
     end
 
     def dump_failures(*args)

data/lib/parallelized_specs/tasks.rb

@@ -44,9 +44,14 @@ namespace :parallel do
   end
 
   desc "run spec in parallel with parallel:spec[num_cpus]"
-  task 'spec', :count, :pattern, :options, :arguments do |t, args|
-    count, pattern = ParallelizedSpecs.parse_rake_args(args)
-    opts = {:count => count, :pattern => pattern, :root => Rails.root, :files => args[:arguments]}
-    ParallelizedSpecs.execute_parallel_specs(opts)
+    task 'spec', :count, :pattern, :options, :arguments do |t, 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
+
+  desc "reruns all the failed specs in 1 thread"
+  task 'rerun' do
+    ParallelizedSpecs.rerun()
   end
 end

data/parallelized_specs.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "parallelized_specs"
-  s.version = "0.3.23"
+  s.version = "0.3.24"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Jake Sorce, Bryan Madsen, Shawn Meredith"]
-  s.date = "2012-10-29"
+  s.date = "2012-10-30"
   s.email = "jake@instructure.com"
   s.files = [
     "Gemfile",

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: parallelized_specs
 version: !ruby/object:Gem::Version 
-  hash: 61
+  hash: 35
   prerelease: 
   segments: 
   - 0
   - 3
-  - 23
-  version: 0.3.23
+  - 24
+  version: 0.3.24
 platform: ruby
 authors: 
 - Jake Sorce, Bryan Madsen, Shawn Meredith
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-10-29 00:00:00 Z
+date: 2012-10-30 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: parallel