parallel_tests 1.1.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d378dd684c7e7a13876bc30b017c2d7d38a65238
-  data.tar.gz: 15a61d401253bcff02d591f5d73345beb3244fec
+  metadata.gz: d9936778844bea92756c550ca9ca6c224406ce07
+  data.tar.gz: 2e410f1e0d4b8e76b5eb0558bfc5fa01117650ee
 SHA512:
-  metadata.gz: 3a743c635bd8a247d26536bb163f1b5383edc75c5e4cc9ca923d774a81df3656cdac6cfd15ebab70ead6293e07b7b71633d90d71e8c687f9968b36ebfab6a0ad
-  data.tar.gz: 788fd6fb129d348952fe7ed52314d19d573c59f420fbbe06a9a2b08937ca7dd50a454f267154a80325f4845b1c18d563382909b4ebf34985336f7ae3d6e05689
+  metadata.gz: eff8a7aa09428d7ac292d767b4ab79ff5a590c03e11d87e57764da3809bc933084d6ab34a23a848d519021e22fa220e33ff660f0f6eb681eb62c59c18153314a
+  data.tar.gz: aaf9d2d50339745e6c5f6a80d70000fd2b6f26f4ed36196a8dbc1e97b8e781e373195669cf127377d7264054d4988797076720c13e18a75f67e5ef165c279240

data/lib/parallel_tests/cli.rb

@@ -0,0 +1,207 @@
+require 'optparse'
+require 'tempfile'
+require 'parallel_tests'
+
+module ParallelTests
+  class CLI
+    def run(argv)
+      options = parse_options!(argv)
+
+      num_processes = ParallelTests.determine_number_of_processes(options[:count])
+      num_processes = num_processes * (options[:multiply] || 1)
+
+      if options[:execute]
+        execute_shell_command_in_parallel(options[:execute], num_processes, options)
+      else
+        run_tests_in_parallel(num_processes, options)
+      end
+    end
+
+    private
+
+    def execute_in_parallel(items, num_processes, options)
+      Tempfile.open 'parallel_tests-lock' do |lock|
+        return Parallel.map(items, :in_threads => num_processes) do |item|
+          result = yield(item)
+          report_output(result, lock) if options[:serialize_stdout]
+          result
+        end
+      end
+    end
+
+    def run_tests_in_parallel(num_processes, options)
+      test_results = nil
+
+      report_time_taken do
+        groups = @runner.tests_in_groups(options[:files], num_processes, options)
+
+        test_results = if options[:only_group]
+          groups_to_run = options[:only_group].collect{|i| groups[i - 1]}
+          report_number_of_tests(groups_to_run)
+          execute_in_parallel(groups_to_run, groups_to_run.size, options) do |group|
+            run_tests(group, groups_to_run.index(group), 1, options)
+          end
+        else
+          report_number_of_tests(groups)
+
+          execute_in_parallel(groups, groups.size, options) do |group|
+            run_tests(group, groups.index(group), num_processes, options)
+          end
+        end
+
+        report_results(test_results)
+      end
+
+      abort final_fail_message if any_test_failed?(test_results)
+    end
+
+    def run_tests(group, process_number, num_processes, options)
+      if group.empty?
+        {:stdout => '', :exit_status => 0}
+      else
+        @runner.run_tests(group, process_number, num_processes, options)
+      end
+    end
+
+    def report_output(result, lock)
+      lock.flock File::LOCK_EX
+      $stdout.puts result[:stdout]
+      $stdout.flush
+    ensure
+      lock.flock File::LOCK_UN
+    end
+
+    def report_results(test_results)
+      results = @runner.find_results(test_results.map { |result| result[:stdout] }*"")
+      puts ""
+      puts @runner.summarize_results(results)
+    end
+
+    def report_number_of_tests(groups)
+      name = @runner.test_file_name
+      num_processes = groups.size
+      num_tests = groups.map(&:size).inject(:+)
+      puts "#{num_processes} processes for #{num_tests} #{name}s, ~ #{num_tests / groups.size} #{name}s per process"
+    end
+
+    #exit with correct status code so rake parallel:test && echo 123 works
+    def any_test_failed?(test_results)
+      test_results.any? { |result| result[:exit_status] != 0 }
+    end
+
+    def parse_options!(argv)
+      options = {}
+      OptionParser.new do |opts|
+        opts.banner = <<-BANNER.gsub(/^          /, '')
+          Run all tests in parallel, giving each process ENV['TEST_ENV_NUMBER'] ('', '2', '3', ...)
+
+          [optional] Only run selected files & folders:
+              parallel_test test/bar test/baz/xxx_text.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("--group-by [TYPE]", <<-TEXT.gsub(/^          /, '')
+          group tests by:
+                    found - order of finding files
+                    steps - number of cucumber/spinach steps
+                    scenarios - individual cucumber scenarios
+                    filesize - by size of the file
+                    default - runtime or filesize
+          TEXT
+          ) { |type| options[:group_by] = type.to_sym }
+        opts.on("-m [FLOAT]", "--multiply-processes [FLOAT]", Float, "use given number as a multiplier of processes to run") { |multiply| options[:multiply] = multiply }
+
+        opts.on("-s [PATTERN]", "--single [PATTERN]",
+          "Run all matching files in the same process") do |pattern|
+
+          options[:single_process] ||= []
+          options[:single_process] << /#{pattern}/
+        end
+
+        opts.on("-i", "--isolate",
+          "Do not run any other tests in the group used by --single(-s)") do |pattern|
+
+          options[:isolate] = true
+        end
+
+        opts.on("--only-group INT[, INT]", Array) { |groups| options[:only_group] = groups.map(&:to_i) }
+
+        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]", "test(default) / rspec / cucumber / spinach") do |type|
+          begin
+            @runner = load_runner(type)
+          rescue NameError, LoadError => e
+            puts "Runner for `#{type}` type has not been found! (#{e})"
+            abort
+          end
+        end
+        opts.on("--serialize-stdout", "Serialize stdout output, nothing will be written until everything is done") { options[:serialize_stdout] = true }
+        opts.on("--combine-stderr", "Combine stderr into stdout, useful in conjunction with --serialize-stdout") { options[:combine_stderr] = true }
+        opts.on("--non-parallel", "execute same commands but do not in parallel, needs --exec") { options[:non_parallel] = true }
+        opts.on("--no-symlinks", "Do not traverse symbolic links to find test files") { options[:symlinks] = false }
+        opts.on('--ignore-tags [PATTERN]', 'When counting steps ignore scenarios with tags that match this pattern')  { |arg| options[:ignore_tag_pattern] = arg }
+        opts.on("--nice", "execute test commands with low priority.") { options[:nice] = true }
+        opts.on("--runtime-log [PATH]", "Location of previously recorded test runtimes") { |path| options[:runtime_log] = path }
+        opts.on("--verbose", "Print more output") { options[:verbose] = true }
+        opts.on("-v", "--version", "Show Version") { puts ParallelTests::VERSION; exit }
+        opts.on("-h", "--help", "Show this.") { puts opts; exit }
+      end.parse!(argv)
+
+      if options[:count] == 0
+        options.delete(:count)
+        options[:non_parallel] = true
+      end
+
+      options[:files] = argv
+
+      options[:group_by] ||= :filesize if options[:only_group]
+
+      raise "--group-by found and --single-process are not supported" if options[:group_by] == :found and options[:single_process]
+      raise "--group-by filesize is required for --only-group" if options[:group_by] != :filesize and options[:only_group]
+
+      options
+    end
+
+    def load_runner(type)
+      require "parallel_tests/#{type}/runner"
+      runner_classname = type.split("_").map(&:capitalize).join.sub("Rspec", "RSpec")
+      klass_name = "ParallelTests::#{runner_classname}::Runner"
+      klass_name.split('::').inject(Object) { |x, y| x.const_get(y) }
+    end
+
+    def execute_shell_command_in_parallel(command, num_processes, options)
+      runs = (0...num_processes).to_a
+      results = if options[:non_parallel]
+        runs.map do |i|
+          ParallelTests::Test::Runner.execute_command(command, i, num_processes, options)
+        end
+      else
+        execute_in_parallel(runs, num_processes, options) do |i|
+          ParallelTests::Test::Runner.execute_command(command, i, num_processes, options)
+        end
+      end.flatten
+
+      abort if results.any? { |r| r[:exit_status] != 0 }
+    end
+
+    def report_time_taken
+      start = Time.now
+      yield
+      puts "\nTook #{Time.now - start} seconds"
+    end
+
+    def final_fail_message
+      fail_message = "#{@runner.name}s Failed"
+      fail_message = "\e[31m#{fail_message}\e[0m" if use_colors?
+
+      fail_message
+    end
+
+    def use_colors?
+      $stdout.tty?
+    end
+  end
+end

data/lib/parallel_tests/cucumber/failures_logger.rb

@@ -0,0 +1,25 @@
+require 'cucumber/formatter/rerun'
+require 'parallel_tests/gherkin/io'
+
+module ParallelTests
+  module Cucumber
+    class FailuresLogger < ::Cucumber::Formatter::Rerun
+      include ParallelTests::Gherkin::Io
+
+      def initialize(runtime, path_or_io, options)
+        @io = prepare_io(path_or_io)
+      end
+
+      def after_feature(feature)
+        unless @lines.empty?
+          lock_output do
+            @lines.each do |line|
+              @io.puts "#{feature.file}:#{line}"
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/parallel_tests/cucumber/runner.rb

@@ -0,0 +1,37 @@
+require "parallel_tests/gherkin/runner"
+
+module ParallelTests
+  module Cucumber
+    class Runner < ParallelTests::Gherkin::Runner
+      class << self
+        def name
+          'cucumber'
+        end
+
+        def line_is_result?(line)
+          super or line =~ failing_scenario_regex
+        end
+
+        def summarize_results(results)
+          output = []
+
+          failing_scenarios = results.grep(failing_scenario_regex)
+          if failing_scenarios.any?
+            failing_scenarios.unshift("Failing Scenarios:")
+            output << failing_scenarios.join("\n")
+          end
+
+          output << super
+
+          output.join("\n\n")
+        end
+
+        private
+
+        def failing_scenario_regex
+          /^cucumber features\/.+:\d+/
+        end
+      end
+    end
+  end
+end

data/lib/parallel_tests/cucumber/scenario_line_logger.rb

@@ -0,0 +1,51 @@
+require 'gherkin/tag_expression'
+
+module ParallelTests
+  module Cucumber
+    module Formatters
+      class ScenarioLineLogger
+        attr_reader :scenarios
+
+        def initialize(tag_expression = ::Gherkin::TagExpression.new([]))
+          @scenarios = []
+          @tag_expression = tag_expression
+        end
+
+        def visit_feature_element(feature_element)
+          return unless @tag_expression.evaluate(feature_element.source_tags)
+
+          case feature_element
+          when ::Cucumber::Ast::Scenario
+            line = if feature_element.respond_to?(:line)
+              feature_element.line
+            else
+              feature_element.instance_variable_get(:@line)
+            end
+            @scenarios << [feature_element.feature.file, line].join(":")
+          when ::Cucumber::Ast::ScenarioOutline
+            sections = feature_element.instance_variable_get(:@example_sections)
+            sections.each { |section|
+              rows = if section[1].respond_to?(:rows)
+                section[1].rows
+              else
+                section[1].instance_variable_get(:@rows)
+              end
+              rows.each_with_index { |row, index|
+                next if index == 0  # slices didn't work with jruby data structure
+                line = if row.respond_to?(:line)
+                  row.line
+                else
+                  row.instance_variable_get(:@line)
+                end
+                @scenarios << [feature_element.feature.file, line].join(":")
+              }
+            }
+          end
+        end
+
+        def method_missing(*args)
+        end
+      end
+    end
+  end
+end

data/lib/parallel_tests/cucumber/scenarios.rb

@@ -0,0 +1,34 @@
+require 'gherkin/tag_expression'
+require 'cucumber/runtime'
+require 'cucumber'
+require 'parallel_tests/cucumber/scenario_line_logger'
+require 'parallel_tests/gherkin/listener'
+
+module ParallelTests
+  module Cucumber
+    class Scenarios
+      class << self
+        def all(files, options={})
+          tags = []
+          tags.concat options[:ignore_tag_pattern].to_s.split(/\s*,\s*/).map {|tag| "~#{tag}" }
+          tags.concat options[:test_options].to_s.scan(/(?:-t|--tags) (~?@[\w,~@]+)/).flatten
+          split_into_scenarios files, tags.uniq
+        end
+
+        private
+
+        def split_into_scenarios(files, tags=[])
+          tag_expression = ::Gherkin::TagExpression.new(tags)
+          scenario_line_logger = ParallelTests::Cucumber::Formatters::ScenarioLineLogger.new(tag_expression)
+          loader = ::Cucumber::Runtime::FeaturesLoader.new(files, [], tag_expression)
+
+          loader.features.each do |feature|
+            feature.accept(scenario_line_logger)
+          end
+
+          scenario_line_logger.scenarios
+        end
+      end
+    end
+  end
+end

data/lib/parallel_tests/gherkin/io.rb

@@ -0,0 +1,41 @@
+require 'parallel_tests'
+
+module ParallelTests
+  module Gherkin
+    module Io
+
+      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/gherkin/listener.rb

@@ -0,0 +1,87 @@
+require 'gherkin'
+
+module ParallelTests
+  module Gherkin
+    class Listener
+      attr_reader :collect
+
+      attr_writer :ignore_tag_pattern
+
+      def initialize
+        @steps, @uris = [], []
+        @collect = {}
+        reset_counters!
+      end
+
+      def feature(feature)
+        @feature = feature
+      end
+
+      def background(*args)
+        @background = 1
+      end
+
+      def scenario(scenario)
+        @outline = @background = 0
+        return if should_ignore(scenario)
+        @scenarios += 1
+      end
+
+      def scenario_outline(outline)
+        return if should_ignore(outline)
+        @outline = 1
+      end
+
+      def step(*args)
+        return if @ignoring
+        if @background == 1
+          @background_steps += 1
+        elsif @outline > 0
+          @outline_steps += 1
+        else
+          @collect[@uri] += 1
+        end
+      end
+
+      def uri(path)
+        @uri = path
+        @collect[@uri] = 0
+      end
+
+      #
+      # @param  [Gherkin::Formatter::Model::Examples]  examples
+      #
+      def examples(examples)
+        if examples.rows.size > 0
+          @collect[@uri] += (@outline_steps * examples.rows.size)
+        end
+      end
+
+      def eof(*args)
+        @collect[@uri] += (@background_steps * @scenarios)
+        reset_counters!
+      end
+
+      def reset_counters!
+        @outline = @outline_steps = @background = @background_steps = @scenarios = 0
+        @ignoring = nil
+      end
+
+      # ignore lots of other possible callbacks ...
+      def method_missing(*args)
+      end
+
+      private
+
+      # Return a combination of tags declared on this scenario/outline and the feature it belongs to
+      def all_tags(scenario)
+        (scenario.tags || []) + ((@feature && @feature.tags) || [])
+      end
+
+      # Set @ignoring if we should ignore this scenario/outline based on its tags
+      def should_ignore(scenario)
+        @ignoring = @ignore_tag_pattern && all_tags(scenario).find{ |tag| @ignore_tag_pattern === tag.name }
+      end
+    end
+  end
+end