parallel_tests 0.13.3 → 0.14.0

data/lib/parallel_tests/{cucumber → gherkin}/runtime_logger.rb

@@ -1,7 +1,7 @@
-require 'parallel_tests/cucumber/io'
+require 'parallel_tests/gherkin/io'
 
 module ParallelTests
-  module Cucumber
+  module Gherkin
     class RuntimeLogger
       include Io
 

data/lib/parallel_tests/grouper.rb

@@ -1,56 +1,56 @@
 module ParallelTests
   class Grouper
-    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 }
-        matched.each { |item, size| add_to_group(groups.first, item, size) }
+    class << self
+      def by_steps(tests, num_groups, options)
+        features_with_steps = build_features_with_steps(tests, options)
+        in_even_groups_by_size(features_with_steps, num_groups)
       end
 
-      groups_to_fill = (options[:isolate] ? groups[1..-1] : groups)
+      def in_even_groups_by_size(items_with_sizes, num_groups, options = {})
+        groups = Array.new(num_groups) { {:items => [], :size => 0} }
 
-      # add all other files
-      largest_first(items_with_sizes).each do |item, size|
-        smallest = smallest_group(groups_to_fill)
-        add_to_group(smallest, item, size)
-      end
+        # 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 }
+          matched.each { |item, size| add_to_group(groups.first, item, size) }
+        end
 
-      groups.map!{|g| g[:items].sort }
-    end
+        groups_to_fill = (options[:isolate] ? groups[1..-1] : groups)
 
-    def self.largest_first(files)
-      files.sort_by{|item, size| size }.reverse
-    end
+        # add all other files
+        largest_first(items_with_sizes).each do |item, size|
+          smallest = smallest_group(groups_to_fill)
+          add_to_group(smallest, item, size)
+        end
 
-    private
+        groups.map!{|g| g[:items].sort }
+      end
 
-    def self.smallest_group(groups)
-      groups.min_by{|g| g[:size] }
-    end
+      private
 
-    def self.add_to_group(group, item, size)
-      group[:items] << item
-      group[:size] += size
-    end
+      def largest_first(files)
+        files.sort_by{|item, size| size }.reverse
+      end
 
-    def self.by_steps(tests, num_groups, options)
-      features_with_steps = build_features_with_steps(tests, options)
-      in_even_groups_by_size(features_with_steps, num_groups)
-    end
+      def smallest_group(groups)
+        groups.min_by{|g| g[:size] }
+      end
 
-    private
-
-    def self.build_features_with_steps(tests, options)
-      require 'parallel_tests/cucumber/gherkin_listener'
-      listener = Cucumber::GherkinListener.new
-      listener.ignore_tag_pattern = Regexp.compile(options[:ignore_tag_pattern]) if options[:ignore_tag_pattern]
-      parser = Gherkin::Parser::Parser.new(listener, true, 'root')
-      tests.each{|file|
-        parser.parse(File.read(file), file, 0)
-      }
-      listener.collect.sort_by{|_,value| -value }
+      def add_to_group(group, item, size)
+        group[:items] << item
+        group[:size] += size
+      end
+
+      def build_features_with_steps(tests, options)
+        require 'parallel_tests/gherkin/listener'
+        listener = ParallelTests::Gherkin::Listener.new
+        listener.ignore_tag_pattern = Regexp.compile(options[:ignore_tag_pattern]) if options[:ignore_tag_pattern]
+        parser = ::Gherkin::Parser::Parser.new(listener, true, 'root')
+        tests.each{|file|
+          parser.parse(File.read(file), file, 0)
+        }
+        listener.collect.sort_by{|_,value| -value }
+      end
     end
   end
 end

data/lib/parallel_tests/rspec/failures_logger.rb

@@ -38,7 +38,7 @@ class ParallelTests::RSpec::FailuresLogger < ParallelTests::RSpec::LoggerBase
       file, line = example.location.to_s.split(':')
       next unless file and line
       file.gsub!(%r(^.*?/spec/), './spec/')
-      @output.puts "#{ParallelTests::RSpec::Runner.executable} #{file}:#{line} # #{example.description}"
+      @output.puts "#{ParallelTests::RSpec::Runner.send(:executable)} #{file}:#{line} # #{example.description}"
     end
   end
 end

data/lib/parallel_tests/rspec/runner.rb

@@ -5,65 +5,67 @@ module ParallelTests
     class Runner < ParallelTests::Test::Runner
       NAME = 'RSpec'
 
-      def self.run_tests(test_files, process_number, num_processes, options)
-        exe = executable # expensive, so we cache
-        version = (exe =~ /\brspec\b/ ? 2 : 1)
-        cmd = [exe, options[:test_options], (rspec_2_color if version == 2), spec_opts, *test_files].compact.join(" ")
-        options = options.merge(:env => rspec_1_color) if version == 1
-        execute_command(cmd, process_number, num_processes, options)
-      end
-
-      def self.determine_executable
-        cmd = case
-        when File.exists?("bin/rspec")
-          "bin/rspec"
-        when File.file?("script/spec")
-          "script/spec"
-        when ParallelTests.bundler_enabled?
-          cmd = (run("bundle show rspec-core") =~ %r{Could not find gem.*} ? "spec" : "rspec")
-          "bundle exec #{cmd}"
-        else
-          %w[spec rspec].detect{|cmd| system "#{cmd} --version > /dev/null 2>&1" }
+      class << self
+        def run_tests(test_files, process_number, num_processes, options)
+          exe = executable # expensive, so we cache
+          version = (exe =~ /\brspec\b/ ? 2 : 1)
+          cmd = [exe, options[:test_options], (rspec_2_color if version == 2), spec_opts, *test_files].compact.join(" ")
+          options = options.merge(:env => rspec_1_color) if version == 1
+          execute_command(cmd, process_number, num_processes, options)
         end
 
-        cmd or raise("Can't find executables rspec or spec")
-      end
+        def determine_executable
+          cmd = case
+          when File.exists?("bin/rspec")
+            "bin/rspec"
+          when File.file?("script/spec")
+            "script/spec"
+          when ParallelTests.bundler_enabled?
+            cmd = (run("bundle show rspec-core") =~ %r{Could not find gem.*} ? "spec" : "rspec")
+            "bundle exec #{cmd}"
+          else
+            %w[spec rspec].detect{|cmd| system "#{cmd} --version > /dev/null 2>&1" }
+          end
 
-      def self.runtime_log
-        'tmp/parallel_runtime_rspec.log'
-      end
+          cmd or raise("Can't find executables rspec or spec")
+        end
 
-      def self.test_file_name
-        "spec"
-      end
+        def runtime_log
+          'tmp/parallel_runtime_rspec.log'
+        end
 
-      def self.test_suffix
-        "_spec.rb"
-      end
+        def test_file_name
+          "spec"
+        end
 
-      private
+        def test_suffix
+          "_spec.rb"
+        end
 
-      # so it can be stubbed....
-      def self.run(cmd)
-        `#{cmd}`
-      end
+        private
 
-      def self.rspec_1_color
-        if $stdout.tty?
-          {'RSPEC_COLOR' => "1"}
-        else
-          {}
+        # so it can be stubbed....
+        def run(cmd)
+          `#{cmd}`
         end
-      end
 
-      def self.rspec_2_color
-        '--color --tty' if $stdout.tty?
-      end
+        def rspec_1_color
+          if $stdout.tty?
+            {'RSPEC_COLOR' => "1"}
+          else
+            {}
+          end
+        end
+
+        def rspec_2_color
+          '--color --tty' if $stdout.tty?
+        end
 
-      def self.spec_opts
-        options_file = ['.rspec_parallel', 'spec/parallel_spec.opts', 'spec/spec.opts'].detect{|f| File.file?(f) }
-        return unless options_file
-        "-O #{options_file}"
+        def spec_opts
+          options_file = ['.rspec_parallel', 'spec/parallel_spec.opts', 'spec/spec.opts'].detect{|f| File.file?(f) }
+          return unless options_file
+          "-O #{options_file}"
+        end
       end
     end
   end

data/lib/parallel_tests/spinach/runner.rb

@@ -0,0 +1,19 @@
+require "parallel_tests/gherkin/runner"
+
+module ParallelTests
+  module Spinach
+    class Runner < ParallelTests::Gherkin::Runner
+      class << self
+        def name
+          'spinach'
+        end
+
+        def runtime_logging
+          #Not Yet Supported
+          ""
+        end
+
+      end
+    end
+  end
+end

data/lib/parallel_tests/tasks.rb

@@ -111,7 +111,7 @@ namespace :parallel do
     ParallelTests::Tasks.run_in_parallel("RAILS_ENV=#{ParallelTests::Tasks.rails_env} rake #{args.command}")
   end
 
-  ['test', 'spec', 'features'].each do |type|
+  ['test', 'spec', 'features', 'features-spinach'].each do |type|
     desc "run #{type} in parallel with parallel:#{type}[num_cpus]"
     task type, [:count, :pattern, :options] do |t, args|
       ParallelTests::Tasks.check_for_pending_migrations
@@ -123,15 +123,19 @@ namespace :parallel do
       test_framework = {
         'spec' => 'rspec',
         'test' => 'test',
-        'features' => 'cucumber'
+        'features' => 'cucumber',
+        'features-spinach' => 'spinach',
       }[type]
 
+      if test_framework == 'spinach'
+        type = 'features'
+      end
       executable = File.join(File.dirname(__FILE__), '..', '..', 'bin', 'parallel_test')
+
       command = "#{executable} #{type} --type #{test_framework} " \
         "-n #{count} "                     \
         "--pattern '#{pattern}' "          \
         "--test-options '#{options}'"
-
       abort unless system(command) # allow to chain tasks e.g. rake parallel:spec parallel:features
     end
   end

data/lib/parallel_tests/test/runner.rb

@@ -5,160 +5,162 @@ module ParallelTests
     class Runner
       NAME = 'Test'
 
-      # --- usually overwritten by other runners
+      class << self
+        # --- usually overwritten by other runners
 
-      def self.name
-        NAME
-      end
+        def name
+          NAME
+        end
 
-      def self.runtime_log
-        'tmp/parallel_runtime_test.log'
-      end
+        def runtime_log
+          'tmp/parallel_runtime_test.log'
+        end
 
-      def self.test_suffix
-        "_test.rb"
-      end
+        def test_suffix
+          "_test.rb"
+        end
 
-      def self.test_file_name
-        "test"
-      end
+        def test_file_name
+          "test"
+        end
 
-      def self.run_tests(test_files, process_number, num_processes, options)
-        require_list = test_files.map { |filename| %{"#{File.expand_path filename}"} }.join(",")
-        cmd = "#{executable} -Itest -e '[#{require_list}].each {|f| require f }' -- #{options[:test_options]}"
-        execute_command(cmd, process_number, num_processes, options)
-      end
+        def run_tests(test_files, process_number, num_processes, options)
+          require_list = test_files.map { |filename| %{"#{File.expand_path filename}"} }.join(",")
+          cmd = "#{executable} -Itest -e '[#{require_list}].each {|f| require f }' -- #{options[:test_options]}"
+          execute_command(cmd, process_number, num_processes, options)
+        end
 
-      def self.line_is_result?(line)
-        line =~ /\d+ failure/
-      end
+        def line_is_result?(line)
+          line =~ /\d+ failure/
+        end
 
-      # --- usually used by other runners
+        # --- usually used by other runners
 
-      # finds all tests and partitions them into groups
-      def self.tests_in_groups(tests, num_groups, options={})
-        tests = find_tests(tests, options)
+        # finds all tests and partitions them into groups
+        def tests_in_groups(tests, num_groups, options={})
+          tests = find_tests(tests, options)
 
-        tests = if options[:group_by] == :found
-          tests.map { |t| [t, 1] }
-        else
-          with_runtime_info(tests)
+          tests = if options[:group_by] == :found
+            tests.map { |t| [t, 1] }
+          else
+            with_runtime_info(tests)
+          end
+          Grouper.in_even_groups_by_size(tests, num_groups, options)
         end
-        Grouper.in_even_groups_by_size(tests, num_groups, options)
-      end
 
-      def self.execute_command(cmd, process_number,  num_processes, options)
-        env = (options[:env] || {}).merge(
-          "TEST_ENV_NUMBER" => test_env_number(process_number),
-          "PARALLEL_TEST_GROUPS" => num_processes
-        )
-        cmd = "nice #{cmd}" if options[:nice]
-        execute_command_and_capture_output(env, cmd, options[:serialize_stdout])
-      end
+        def execute_command(cmd, process_number,  num_processes, options)
+          env = (options[:env] || {}).merge(
+            "TEST_ENV_NUMBER" => test_env_number(process_number),
+            "PARALLEL_TEST_GROUPS" => num_processes
+          )
+          cmd = "nice #{cmd}" if options[:nice]
+          execute_command_and_capture_output(env, cmd, options[:serialize_stdout])
+        end
 
-      def self.execute_command_and_capture_output(env, cmd, silence)
-        # make processes descriptive / visible in ps -ef
-        exports = env.map do |k,v|
-          "#{k}=#{v};export #{k}"
-        end.join(";")
-        cmd = "#{exports};#{cmd}"
+        def execute_command_and_capture_output(env, cmd, silence)
+          # make processes descriptive / visible in ps -ef
+          exports = env.map do |k,v|
+            "#{k}=#{v};export #{k}"
+          end.join(";")
+          cmd = "#{exports};#{cmd}"
 
-        output = open("|#{cmd}", "r") { |output| capture_output(output, silence) }
-        exitstatus = $?.exitstatus
+          output = open("|#{cmd}", "r") { |output| capture_output(output, silence) }
+          exitstatus = $?.exitstatus
 
-        {:stdout => output, :exit_status => exitstatus}
-      end
+          {:stdout => output, :exit_status => exitstatus}
+        end
 
-      def self.find_results(test_output)
-        test_output.split("\n").map {|line|
-          line = line.gsub(/\.|F|\*/,'').gsub(/\e\[\d+m/,'')
-          next unless line_is_result?(line)
-          line
-        }.compact
-      end
+        def find_results(test_output)
+          test_output.split("\n").map {|line|
+            line = line.gsub(/\.|F|\*/,'').gsub(/\e\[\d+m/,'')
+            next unless line_is_result?(line)
+            line
+          }.compact
+        end
 
-      def self.test_env_number(process_number)
-        process_number == 0 ? '' : process_number + 1
-      end
+        def test_env_number(process_number)
+          process_number == 0 ? '' : process_number + 1
+        end
 
-      def self.summarize_results(results)
-        sums = sum_up_results(results)
-        sums.sort.map{|word, number|  "#{number} #{word}#{'s' if number != 1}" }.join(', ')
-      end
+        def summarize_results(results)
+          sums = sum_up_results(results)
+          sums.sort.map{|word, number|  "#{number} #{word}#{'s' if number != 1}" }.join(', ')
+        end
 
-      protected
+        protected
 
-      def self.executable
-        ENV['PARALLEL_TESTS_EXECUTABLE'] || determine_executable
-      end
+        def executable
+          ENV['PARALLEL_TESTS_EXECUTABLE'] || determine_executable
+        end
 
-      def self.determine_executable
-        "ruby"
-      end
+        def determine_executable
+          "ruby"
+        end
 
-      def self.sum_up_results(results)
-        results = results.join(' ').gsub(/s\b/,'') # combine and singularize results
-        counts = results.scan(/(\d+) (\w+)/)
-        counts.inject(Hash.new(0)) do |sum, (number, word)|
-          sum[word] += number.to_i
-          sum
+        def sum_up_results(results)
+          results = results.join(' ').gsub(/s\b/,'') # combine and singularize results
+          counts = results.scan(/(\d+) (\w+)/)
+          counts.inject(Hash.new(0)) do |sum, (number, word)|
+            sum[word] += number.to_i
+            sum
+          end
         end
-      end
 
-      # read output of the process and print it in chunks
-      def self.capture_output(out, silence)
-        result = ""
-        loop do
-          begin
-            read = out.readpartial(1000000) # read whatever chunk we can get
-            result << read
-            unless silence
-              $stdout.print read
-              $stdout.flush
+        # read output of the process and print it in chunks
+        def capture_output(out, silence)
+          result = ""
+          loop do
+            begin
+              read = out.readpartial(1000000) # read whatever chunk we can get
+              result << read
+              unless silence
+                $stdout.print read
+                $stdout.flush
+              end
             end
-          end
-        end rescue EOFError
-        result
-      end
+          end rescue EOFError
+          result
+        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
+        def 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[File.expand_path(test)]] }
+          else # use file sizes
+            tests.sort.map{|test| [test, File.stat(test).size] }
           end
-          tests.sort.map{|test| [test, times[File.expand_path(test)]] }
-        else # use file sizes
-          tests.sort.map{|test| [test, File.stat(test).size] }
         end
-      end
 
-      def self.find_tests(tests, options = {})
-        (tests || []).map do |file_or_folder|
-          if File.directory?(file_or_folder)
-            files = files_in_folder(file_or_folder, options)
-            files.grep(/#{Regexp.escape test_suffix}$/).grep(options[:pattern]||//)
+        def find_tests(tests, options = {})
+          (tests || []).map do |file_or_folder|
+            if File.directory?(file_or_folder)
+              files = files_in_folder(file_or_folder, options)
+              files.grep(/#{Regexp.escape test_suffix}$/).grep(options[:pattern]||//)
+            else
+              file_or_folder
+            end
+          end.flatten.uniq
+        end
+
+        def files_in_folder(folder, options={})
+          pattern = if options[:symlinks] == false # not nil or true
+            "**/*"
           else
-            file_or_folder
+            # follow one symlink and direct children
+            # http://stackoverflow.com/questions/357754/can-i-traverse-symlinked-directories-in-ruby-with-a-glob
+            "**{,/*/**}/*"
           end
-        end.flatten.uniq
-      end
-
-      def self.files_in_folder(folder, options={})
-        pattern = if options[:symlinks] == false # not nil or true
-          "**/*"
-        else
-          # follow one symlink and direct children
-          # http://stackoverflow.com/questions/357754/can-i-traverse-symlinked-directories-in-ruby-with-a-glob
-          "**{,/*/**}/*"
+          Dir[File.join(folder, pattern)].uniq
         end
-        Dir[File.join(folder, pattern)].uniq
       end
     end
   end