parallel_tests 1.0.9 → 1.1.0

data/lib/parallel_tests/cucumber/failures_logger.rb

@@ -1,25 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,87 +0,0 @@
-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

data/lib/parallel_tests/gherkin/runner.rb

@@ -1,116 +0,0 @@
-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.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.exists?("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/gherkin/runtime_logger.rb

@@ -1,28 +0,0 @@
-require 'parallel_tests/gherkin/io'
-
-module ParallelTests
-  module Gherkin
-    class RuntimeLogger
-      include Io
-
-      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 = ParallelTests.now.to_f
-      end
-
-      def after_feature(feature)
-        @example_times[feature.file] += ParallelTests.now.to_f - @start_at
-      end
-
-      def after_features(*args)
-        lock_output do
-          @io.puts @example_times.map { |file, time| "#{file}:#{time}" }
-        end
-      end
-    end
-  end
-end

data/lib/parallel_tests/grouper.rb

@@ -1,73 +0,0 @@
-module ParallelTests
-  class Grouper
-    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
-
-      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 = 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)
-
-        groups.map!{|g| g[:items].sort }
-      end
-
-      private
-
-      def largest_first(files)
-        files.sort_by{|item, size| size }.reverse
-      end
-
-      def smallest_group(groups)
-        groups.min_by{|g| g[:size] }
-      end
-
-      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
-
-      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
-end