parallel_tests 0.6.20 → 0.7.0.alpha

data/lib/parallel_tests/cucumber/runner.rb

@@ -0,0 +1,40 @@
+require 'parallel_tests/test/runner'
+
+module ParallelTests
+  module Cucumber
+    class Runner < ParallelTests::Test::Runner
+      def self.run_tests(test_files, process_number, options)
+        color = ($stdout.tty? ? 'AUTOTEST=1 ; export AUTOTEST ;' : '')#display color when we are in a terminal
+        runtime_logging = " --format ParallelCucumber::RuntimeLogger --out #{runtime_log}"
+        cmd = "#{color} #{executable}"
+        cmd << runtime_logging if File.directory?(File.dirname(runtime_log))
+        cmd << " #{options[:test_options]} #{test_files*' '}"
+        execute_command(cmd, process_number, options)
+      end
+
+      def self.executable
+        if ParallelTests.bundler_enabled?
+          "bundle exec cucumber"
+        elsif File.file?("script/cucumber")
+          "script/cucumber"
+        else
+          "cucumber"
+        end
+      end
+
+      def self.runtime_log
+        'tmp/parallel_runtime_cucumber.log'
+      end
+
+      protected
+
+      def self.test_suffix
+        ".feature"
+      end
+
+      def self.line_is_result?(line)
+        line =~ /^\d+ (steps|scenarios)/
+      end
+    end
+  end
+end

data/lib/parallel_tests/cucumber/runtime_logger.rb

@@ -0,0 +1,58 @@
+module ParallelTests
+  module Cucumber
+    class RuntimeLogger
+      def initialize(step_mother, path_or_io, options=nil)
+        @io = prepare_io(path_or_io)
+        @example_times = Hash.new(0)
+      end
+
+      def before_feature(_)
+        @start_at = Time.now.to_f
+      end
+
+      def after_feature(feature)
+        @example_times[feature.file] += Time.now.to_f - @start_at
+      end
+
+      def after_features(*args)
+        lock_output do
+          @io.puts @example_times.map { |file, time| "#{file}:#{time}" }
+        end
+      end
+
+      private
+
+      def prepare_io(path_or_io)
+        if path_or_io.respond_to?(:write)
+          path_or_io
+        else # its a path
+          File.open(path_or_io, 'w').close # clean out the file
+          file = File.open(path_or_io, 'a')
+
+          at_exit do
+            unless file.closed?
+              file.flush
+              file.close
+            end
+          end
+
+          file
+        end
+      end
+
+      # do not let multiple processes get in each others way
+      def lock_output
+        if File === @io
+          begin
+            @io.flock File::LOCK_EX
+            yield
+          ensure
+            @io.flock File::LOCK_UN
+          end
+        else
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/parallel_tests/grouper.rb

@@ -1,4 +1,4 @@
-class ParallelTests
+module ParallelTests
   class Grouper
     def self.in_groups(items, num_groups)
       groups = Array.new(num_groups){ [] }
@@ -35,7 +35,7 @@ class ParallelTests
       files.sort_by{|item, size| size }.reverse
     end
 
-  private
+    private
 
     def self.smallest_group(groups)
       groups.min_by{|g| g[:size] }

data/lib/parallel_tests/railtie.rb

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

data/lib/{parallel_specs/spec_failures_logger.rb → parallel_tests/spec/failures_logger.rb}

@@ -1,6 +1,7 @@
-require 'parallel_specs/spec_logger_base'
+require 'parallel_tests/spec/logger_base'
+require 'parallel_tests/spec/runner'
 
-class ParallelSpecs::SpecFailuresLogger < ParallelSpecs::SpecLoggerBase
+class ParallelTests::Spec::FailuresLogger < ParallelTests::Spec::LoggerBase
   # RSpec 1: does not keep track of failures, so we do
   def example_failed(example, *args)
     if RSPEC_1
@@ -37,7 +38,7 @@ class ParallelSpecs::SpecFailuresLogger < ParallelSpecs::SpecLoggerBase
       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}"
+      @output.puts "#{ParallelTests::Spec::Runner.executable} #{file}:#{line} # #{example.description}"
     end
   end
 end

data/lib/{parallel_specs/spec_logger_base.rb → parallel_tests/spec/logger_base.rb}

@@ -1,4 +1,7 @@
-require 'parallel_specs'
+module ParallelTests
+  module Spec
+  end
+end
 
 begin
   require 'rspec/core/formatters/base_text_formatter'
@@ -7,9 +10,10 @@ rescue LoadError
   require 'spec/runner/formatter/base_text_formatter'
   base = Spec::Runner::Formatter::BaseTextFormatter
 end
-ParallelSpecs::SpecLoggerBaseBase = base
 
-class ParallelSpecs::SpecLoggerBase < ParallelSpecs::SpecLoggerBaseBase
+ParallelTests::Spec::LoggerBaseBase = base
+
+class ParallelTests::Spec::LoggerBase < ParallelTests::Spec::LoggerBaseBase
   RSPEC_1 = !defined?(RSpec::Core::Formatters::BaseTextFormatter) # do not test for Spec, this will trigger deprecation warning in rspec 2
 
   def initialize(*args)

data/lib/parallel_tests/spec/runner.rb

@@ -0,0 +1,56 @@
+require 'parallel_tests/test/runner'
+
+module ParallelTests
+  module Spec
+    class Runner < ParallelTests::Test::Runner
+      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 ParallelTests.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 = ['.rspec_parallel', '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
+  end
+end

data/lib/{parallel_specs/spec_runtime_logger.rb → parallel_tests/spec/runtime_logger.rb}

@@ -1,6 +1,6 @@
-require 'parallel_specs/spec_logger_base'
+require 'parallel_tests/spec/logger_base'
 
-class ParallelSpecs::SpecRuntimeLogger < ParallelSpecs::SpecLoggerBase
+class ParallelTests::Spec::RuntimeLogger < ParallelTests::Spec::LoggerBase
   def initialize(*args)
     super
     @example_times = Hash.new(0)

data/lib/{parallel_specs/spec_summary_logger.rb → parallel_tests/spec/summary_logger.rb}

@@ -1,6 +1,6 @@
-require 'parallel_specs/spec_failures_logger'
+require 'parallel_tests/spec/failures_logger'
 
-class ParallelSpecs::SpecSummaryLogger < ParallelSpecs::SpecLoggerBase
+class ParallelTests::Spec::SummaryLogger < ParallelTests::Spec::LoggerBase
   # RSpec 1: dumps 1 failed spec
   def dump_failure(*args)
     lock_output do

data/lib/parallel_tests/tasks.rb

@@ -53,28 +53,3 @@ namespace :parallel do
     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

data/lib/parallel_tests/test/runner.rb

@@ -0,0 +1,126 @@
+module ParallelTests
+  module Test
+    class Runner
+      # 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, options)
+        end
+      end
+
+      def self.run_tests(test_files, process_number, options)
+        require_list = test_files.map { |filename| %{"#{File.expand_path 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
+        'tmp/parallel_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
+            $stdout.print buffer
+            $stdout.flush
+            buffer = ''
+            flushed = now
+          end
+        end
+
+        # print the remainder
+        $stdout.print buffer
+        $stdout.flush
+
+        all
+      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(":")
+            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
+  end
+end

data/lib/parallel_tests/test/runtime_logger.rb

@@ -0,0 +1,92 @@
+require 'parallel_tests/test/runner'
+
+module ParallelTests
+  module Test
+    class 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(logfile, 'w'){}
+          @@has_started = true
+        end
+
+        locked_appending_to(logfile) do |file|
+          file.puts(message(test, start_time, end_time))
+        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"
+        "#{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
+
+      def self.locked_appending_to(file)
+        File.open(file, 'a') do |f|
+          begin
+            f.flock File::LOCK_EX
+            yield f
+          ensure
+            f.flock File::LOCK_UN
+          end
+        end
+      end
+
+      def self.logfile
+        ParallelTests::Test::Runner.runtime_log
+      end
+    end
+  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::Test::RuntimeLogger.log(self.tests.first, start_time, end_time)
+  end
+
+  @@timing_installed = true
+end