vinted-parallel_tests 0.13.3 → 1.7.0.1

data/lib/parallel_tests/cucumber/failures_logger.rb

@@ -1,20 +1,22 @@
 require 'cucumber/formatter/rerun'
-require 'parallel_tests/cucumber/io'
+require 'parallel_tests/gherkin/io'
 
 module ParallelTests
   module Cucumber
     class FailuresLogger < ::Cucumber::Formatter::Rerun
-      include Io
+      include ParallelTests::Gherkin::Io
 
       def initialize(runtime, path_or_io, options)
+        super
         @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}"
+      def done
+        return if @failures.empty?
+        lock_output do
+          @failures.each do |file, lines|
+            lines.each do |line|
+              @io.print "#{file}:#{line} "
             end
           end
         end

data/lib/parallel_tests/cucumber/runner.rb

@@ -1,96 +1,35 @@
-require "parallel_tests/test/runner"
-require 'shellwords'
+require "parallel_tests/gherkin/runner"
 
 module ParallelTests
   module Cucumber
-    class Runner < ParallelTests::Test::Runner
-      NAME = 'Cucumber'
-
+    class Runner < ParallelTests::Gherkin::Runner
       class << self
-        def run_tests(test_files, process_number, num_processes, options)
-          sanitized_test_files = test_files.map { |val| Shellwords.escape(val) }
-          options = options.merge(:env => {"AUTOTEST" => "1"}) if $stdout.tty? # display color when we are in a terminal
-          runtime_logging = " --format ParallelTests::Cucumber::RuntimeLogger --out #{runtime_log}"
-          cmd = [
-            executable,
-            (runtime_logging if File.directory?(File.dirname(runtime_log))),
-            cucumber_opts(options[:test_options]),
-            *sanitized_test_files
-          ].compact.join(" ")
-          execute_command(cmd, process_number, num_processes, options)
-        end
-
-        def determine_executable
-          case
-          when File.exists?("bin/cucumber")
-            "bin/cucumber"
-          when ParallelTests.bundler_enabled?
-            "bundle exec cucumber"
-          when File.file?("script/cucumber")
-            "script/cucumber"
-          else
-            "cucumber"
-          end
-        end
-
-        def runtime_log
-          'tmp/parallel_runtime_cucumber.log'
-        end
-
-        def test_file_name
-          "feature"
-        end
-
-        def test_suffix
-          ".feature"
+        def name
+          'cucumber'
         end
 
         def line_is_result?(line)
-          line =~ /^\d+ (steps?|scenarios?)/
+          super or line =~ failing_scenario_regex
         end
 
-        # cucumber has 2 result lines per test run, that cannot be added
-        # 1 scenario (1 failed)
-        # 1 step (1 failed)
         def summarize_results(results)
-          sort_order = %w[scenario step failed undefined skipped pending passed]
+          output = []
 
-          %w[scenario step].map do |group|
-            group_results = results.grep /^\d+ #{group}/
-            next if group_results.empty?
+          failing_scenarios = results.grep(failing_scenario_regex)
+          if failing_scenarios.any?
+            failing_scenarios.unshift("Failing Scenarios:")
+            output << failing_scenarios.join("\n")
+          end
 
-            sums = sum_up_results(group_results)
-            sums = sums.sort_by { |word, _| sort_order.index(word) || 999 }
-            sums.map! do |word, number|
-              plural = "s" if word == group and number != 1
-              "#{number} #{word}#{plural}"
-            end
-            "#{sums[0]} (#{sums[1..-1].join(", ")})"
-          end.compact.join("\n")
-        end
+          output << super
 
-        def cucumber_opts(given)
-          if given =~ /--profile/ or given =~ /(^|\s)-p /
-            given
-          else
-            [given, profile_from_config].compact.join(" ")
-          end
+          output.join("\n\n")
         end
 
-        def profile_from_config
-          # copied from https://github.com/cucumber/cucumber/blob/master/lib/cucumber/cli/profile_loader.rb#L85
-          config = Dir.glob('{,.config/,config/}cucumber{.yml,.yaml}').first
-          if config && File.read(config) =~ /^parallel:/
-            "--profile parallel"
-          end
-        end
+        private
 
-        def tests_in_groups(tests, num_groups, options={})
-          if options[:group_by] == :steps
-            Grouper.by_steps(find_tests(tests, options), num_groups, options)
-          else
-            super
-          end
+        def failing_scenario_regex
+          /^cucumber features\/.+:\d+/
         end
       end
     end

data/lib/parallel_tests/cucumber/scenario_line_logger.rb

@@ -0,0 +1,52 @@
+require 'gherkin/tag_expression'
+
+module ParallelTests
+  module Cucumber
+    module Formatters
+      class ScenarioLineLogger
+        attr_reader :scenarios
+
+        def initialize(tag_expression = ::Gherkin::TagExpression.new([]))
+          raise "ScenarioLineLogger not supported anymore after upgrading to Cucumber 2.0, please fix!"
+          @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/{cucumber → gherkin}/io.rb

@@ -1,7 +1,7 @@
 require 'parallel_tests'
 
 module ParallelTests
-  module Cucumber
+  module Gherkin
     module Io
 
       def prepare_io(path_or_io)

data/lib/parallel_tests/{cucumber/gherkin_listener.rb → gherkin/listener.rb}

@@ -1,8 +1,8 @@
 require 'gherkin'
 
 module ParallelTests
-  module Cucumber
-    class GherkinListener
+  module Gherkin
+    class Listener
       attr_reader :collect
 
       attr_writer :ignore_tag_pattern
@@ -48,17 +48,22 @@ module ParallelTests
         @collect[@uri] = 0
       end
 
-      def examples(*args)
-        @examples += 1
+      #
+      # @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) + (@outline_steps * @examples)
+        @collect[@uri] += (@background_steps * @scenarios)
         reset_counters!
       end
 
       def reset_counters!
-        @examples = @outline = @outline_steps = @background = @background_steps = @scenarios = 0
+        @outline = @outline_steps = @background = @background_steps = @scenarios = 0
         @ignoring = nil
       end
 

data/lib/parallel_tests/gherkin/runner.rb

@@ -0,0 +1,116 @@
+require "parallel_tests/test/runner"
+require 'shellwords'
+
+module ParallelTests
+  module Gherkin
+    class Runner < ParallelTests::Test::Runner
+
+      class << self
+        def run_tests(test_files, process_number, num_processes, options)
+          combined_scenarios = test_files
+
+          if options[:group_by] == :scenarios
+            grouped = test_files.map { |t| t.split(':') }.group_by(&:first)
+            combined_scenarios = grouped.map {|file,files_and_lines| "#{file}:#{files_and_lines.map(&:last).join(':')}" }
+          end
+
+          sanitized_test_files = combined_scenarios.map { |val| WINDOWS ? "\"#{val}\"" : Shellwords.escape(val) }
+
+          options[:env] ||= {}
+          options[:env] = options[:env].merge({'AUTOTEST' => '1'}) if $stdout.tty? # display color when we are in a terminal
+
+          cmd = [
+            executable,
+            (runtime_logging if File.directory?(File.dirname(runtime_log))),
+            cucumber_opts(options[:test_options]),
+            *sanitized_test_files
+          ].compact.reject(&:empty?).join(' ')
+          execute_command(cmd, process_number, num_processes, options)
+        end
+
+        def test_file_name
+          @test_file_name || 'feature'
+        end
+
+        def test_suffix
+          /\.feature$/
+        end
+
+        def line_is_result?(line)
+          line =~ /^\d+ (steps?|scenarios?)/
+        end
+
+        # cucumber has 2 result lines per test run, that cannot be added
+        # 1 scenario (1 failed)
+        # 1 step (1 failed)
+        def summarize_results(results)
+          sort_order = %w[scenario step failed undefined skipped pending passed]
+
+          %w[scenario step].map do |group|
+            group_results = results.grep(/^\d+ #{group}/)
+            next if group_results.empty?
+
+            sums = sum_up_results(group_results)
+            sums = sums.sort_by { |word, _| sort_order.index(word) || 999 }
+            sums.map! do |word, number|
+              plural = "s" if word == group and number != 1
+              "#{number} #{word}#{plural}"
+            end
+            "#{sums[0]} (#{sums[1..-1].join(", ")})"
+          end.compact.join("\n")
+        end
+
+        def cucumber_opts(given)
+          if given =~ /--profile/ or given =~ /(^|\s)-p /
+            given
+          else
+            [given, profile_from_config].compact.join(" ")
+          end
+        end
+
+        def profile_from_config
+          # copied from https://github.com/cucumber/cucumber/blob/master/lib/cucumber/cli/profile_loader.rb#L85
+          config = Dir.glob("{,.config/,config/}#{name}{.yml,.yaml}").first
+          if config && File.read(config) =~ /^parallel:/
+            "--profile parallel"
+          end
+        end
+
+        def tests_in_groups(tests, num_groups, options={})
+          if options[:group_by] == :scenarios
+            @test_file_name = "scenario"
+          end
+          method = "by_#{options[:group_by]}"
+          if Grouper.respond_to?(method)
+            Grouper.send(method, find_tests(tests, options), num_groups, options)
+          else
+            super
+          end
+        end
+
+
+        def runtime_logging
+          "--format ParallelTests::Gherkin::RuntimeLogger --out #{runtime_log}"
+        end
+
+        def runtime_log
+          "tmp/parallel_runtime_#{name}.log"
+        end
+
+        def determine_executable
+          case
+          when File.exist?("bin/#{name}")
+            "bin/#{name}"
+          when ParallelTests.bundler_enabled?
+            "bundle exec #{name}"
+          when File.file?("script/#{name}")
+            "script/#{name}"
+          else
+            "#{name}"
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -6,34 +6,34 @@ module ParallelTests
         in_even_groups_by_size(features_with_steps, num_groups)
       end
 
-      def in_even_groups_by_size(items_with_sizes, num_groups, options = {})
+      def by_scenarios(tests, num_groups, options={})
+        scenarios = group_by_scenarios(tests, options)
+        in_even_groups_by_size(scenarios, num_groups)
+      end
+
+      def in_even_groups_by_size(items, 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, items = items.partition { |item, _size| item =~ pattern }
           matched.each { |item, size| add_to_group(groups.first, item, size) }
         end
 
         groups_to_fill = (options[:isolate] ? groups[1..-1] : groups)
+        group_features_by_size(items_to_group(items), groups_to_fill)
 
-        # 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
-
-        groups.map!{|g| g[:items].sort }
+        groups.map! { |g| g[:items].sort }
       end
 
       private
 
       def largest_first(files)
-        files.sort_by{|item, size| size }.reverse
+        files.sort_by{|_item, size| size }.reverse
       end
 
       def smallest_group(groups)
-        groups.min_by{|g| g[:size] }
+        groups.min_by { |g| g[:size] }
       end
 
       def add_to_group(group, item, size)
@@ -42,14 +42,31 @@ module ParallelTests
       end
 
       def build_features_with_steps(tests, options)
-        require 'parallel_tests/cucumber/gherkin_listener'
-        listener = Cucumber::GherkinListener.new
+        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 = ::Gherkin::Parser::Parser.new(listener, true, 'root')
+        tests.each do |file|
           parser.parse(File.read(file), file, 0)
-        }
-        listener.collect.sort_by{|_,value| -value }
+        end
+        listener.collect.sort_by { |_, value| -value }
+      end
+
+      def group_by_scenarios(tests, options={})
+        require 'parallel_tests/cucumber/scenarios'
+        ParallelTests::Cucumber::Scenarios.all(tests, options)
+      end
+
+      def group_features_by_size(items, groups_to_fill)
+        items.each do |item, size|
+          size ||= 1
+          smallest = smallest_group(groups_to_fill)
+          add_to_group(smallest, item, size)
+        end
+      end
+
+      def items_to_group(items)
+        items.first && items.first.size == 2 ? largest_first(items) : items
       end
     end
   end