parallel_cucumber 0.1.22

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0712cec043620fc781e38673adc438452b993e59
+  data.tar.gz: a8c396bf23c857e9f269e36ea24b018b304de8c4
+SHA512:
+  metadata.gz: 2561568ca2d8397944b67171a49839832b422d16135c21b749ca27965706c99165358f520f79f4464724e58978598b07901cc95c298a1a207661fd5fdbc325aa
+  data.tar.gz: 024e7fe7d1c6427080e94a7f572b3b45c3c940224dea48b956085b5be876107408970004953116f00f92d9b884ab2e2f6920d00df81fe003f6a8ecbe181dd91d

data/README.md

@@ -0,0 +1,15 @@
+# Parallel Cucumber
+
+```
+Usage: parallel_cucumber [options] [ [FILE|DIR|URL][:LINE[:LINE]*] ]
+Example: parallel_cucumber -n 4 -o "-f pretty -f html -o report.html" examples/i18n/en/features
+    -n [PROCESSES]                   How many processes to use
+    -o "[OPTIONS]",                  Run cucumber with these options
+        --cucumber-options
+    -e, --env-variables [JSON]       Set additional environment variables to processes
+    -s, --setup-script [SCRIPT]      Execute SCRIPT before each process
+    -t, --teardown-script [SCRIPT]   Execute SCRIPT after each process
+        --thread-delay [SECONDS]     Delay before next thread starting
+    -v, --version                    Show version
+    -h, --help                       Show this
+```

data/bin/parallel_cucumber

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+# Enable local usage from cloned repo
+root = File.expand_path('../..', __FILE__)
+$LOAD_PATH << "#{root}/lib" if File.exist?("#{root}/Gemfile")
+
+require 'parallel_cucumber'
+
+ParallelCucumber::Cli.run(ARGV)

data/lib/parallel_cucumber.rb

@@ -0,0 +1,53 @@
+require 'parallel'
+
+require 'parallel_cucumber/cli'
+require 'parallel_cucumber/grouper'
+require 'parallel_cucumber/result_formatter'
+require 'parallel_cucumber/runner'
+require 'parallel_cucumber/version'
+
+module ParallelCucumber
+  class << self
+    def run_tests_in_parallel(options)
+      number_of_processes = options[:n]
+      test_results = nil
+
+      report_time_taken do
+        groups = Grouper.feature_groups(options, number_of_processes)
+        threads = groups.size
+        completed = []
+
+        on_finish = lambda do |_item, index, _result|
+          completed.push(index)
+          remaining_threads = ((0...threads).to_a - completed).sort
+          puts "Thread #{index} has finished. Remaining(#{remaining_threads.count}): #{remaining_threads.join(', ')}"
+        end
+
+        test_results = Parallel.map_with_index(
+          groups,
+          in_threads: threads,
+          finish: on_finish
+        ) do |group, index|
+          Runner.new(options).run_tests(index, group)
+        end
+        puts 'All threads are complete'
+        ResultFormatter.report_results(test_results)
+      end
+      exit(1) if any_test_failed?(test_results)
+    end
+
+    private
+
+    def any_test_failed?(test_results)
+      test_results.any? { |result| result[:exit_status] != 0 }
+    end
+
+    def report_time_taken
+      start = Time.now
+      yield
+      time_in_sec = Time.now - start
+      mm, ss = time_in_sec.divmod(60)
+      puts "\nTook #{mm} Minutes, #{ss.round(2)} Seconds"
+    end
+  end # class
+end # ParallelCucumber

data/lib/parallel_cucumber/cli.rb

@@ -0,0 +1,79 @@
+require 'json'
+require 'optparse'
+
+module ParallelCucumber
+  module Cli
+    class << self
+      DEFAULTS = {
+        env_variables: {},
+        thread_delay: 0,
+        cucumber_options: '',
+        n: 1
+      }.freeze
+
+      def run(argv)
+        options = parse_options!(argv)
+
+        ParallelCucumber.run_tests_in_parallel(options)
+      end
+
+      private
+
+      def parse_options!(argv)
+        options = DEFAULTS.dup
+
+        option_parser = OptionParser.new do |opts|
+          opts.banner = [
+            'Usage: parallel_cucumber [options] [ [FILE|DIR|URL][:LINE[:LINE]*] ]',
+            'Example: parallel_cucumber -n 4 -o "-f pretty -f html -o report.html" examples/i18n/en/features'
+          ].join("\n")
+          opts.on('-n [PROCESSES]', Integer, 'How many processes to use') { |n| options[:n] = n }
+          opts.on('-o', '--cucumber-options "[OPTIONS]"', 'Run cucumber with these options') do |cucumber_options|
+            options[:cucumber_options] = cucumber_options
+          end
+          opts.on('-e', '--env-variables [JSON]', 'Set additional environment variables to processes') do |env_vars|
+            options[:env_variables] = begin
+              JSON.parse(env_vars)
+            rescue JSON::ParserError
+              puts 'Additional environment variables not in JSON format. And do not forget to escape quotes'
+              exit 1
+            end
+          end
+          opts.on('-s', '--setup-script [SCRIPT]', 'Execute SCRIPT before each process') do |script|
+            check_script(script)
+            options[:setup_script] = File.expand_path(script)
+          end
+          opts.on('-t', '--teardown-script [SCRIPT]', 'Execute SCRIPT after each process') do |script|
+            check_script(script)
+            options[:teardown_script] = File.expand_path(script)
+          end
+          opts.on('--thread-delay [SECONDS]', Float, 'Delay before next thread starting') do |thread_delay|
+            options[:thread_delay] = thread_delay
+          end
+          opts.on('-v', '--version', 'Show version') do
+            puts ParallelCucumber::VERSION
+            exit 0
+          end
+          opts.on('-h', '--help', 'Show this') do
+            puts opts
+            exit 0
+          end
+        end
+
+        option_parser.parse!(argv)
+        options[:cucumber_args] = argv
+
+        options
+      rescue OptionParser::InvalidOption => e
+        puts "Unknown option #{e}"
+        puts option_parser.help
+        exit 1
+      end
+
+      def check_script(path)
+        fail("File '#{path}' does not exist") unless File.exist?(path)
+        fail("File '#{path}' is not executable") unless File.executable?(path)
+      end
+    end # class
+  end # Cli
+end # ParallelCucumber

data/lib/parallel_cucumber/grouper.rb

@@ -0,0 +1,95 @@
+require 'English'
+require 'erb'
+require 'json'
+require 'open3'
+require 'tempfile'
+require 'yaml'
+
+module ParallelCucumber
+  class Grouper
+    class << self
+      def feature_groups(options, group_size)
+        scenario_groups(group_size, options)
+      end
+
+      private
+
+      def scenario_groups(group_size, options)
+        distribution_data = generate_dry_run_report(options)
+        all_runnable_scenarios = distribution_data.map do |feature|
+          next if feature['elements'].nil?
+          feature['elements'].map do |scenario|
+            "#{feature['uri']}:#{scenario['line']}" if ['Scenario', 'Scenario Outline'].include?(scenario['keyword'])
+          end
+        end.flatten.compact
+
+        group_creator(group_size, all_runnable_scenarios)
+      end
+
+      def generate_dry_run_report(options)
+        cucumber_options = options[:cucumber_options]
+        cucumber_options = expand_profiles(cucumber_options) unless cucumber_config_file.nil?
+        cucumber_options = cucumber_options.gsub(/(--format|-f|--out|-o)\s+[^\s]+/, '')
+        result = nil
+
+        Tempfile.open(%w(dry-run .json)) do |f|
+          dry_run_options = "--dry-run --format json --out #{f.path}"
+
+          cmd = "cucumber #{cucumber_options} #{dry_run_options} #{options[:cucumber_args].join(' ')}"
+          _stdout, stderr, status = Open3.capture3(cmd)
+          f.close
+
+          if status != 0
+            cmd = "bundle exec #{cmd}" if ENV['BUNDLE_BIN_PATH']
+            fail("Can't generate dry run report, command exited with #{status}:\n\t#{cmd}\n\t#{stderr}")
+          end
+
+          content = File.read(f.path)
+
+          result = begin
+            JSON.parse(content)
+          rescue JSON::ParserError
+            content = content.length > 1024 ? "#{content[0...1000]} ...[TRUNCATED]..." : content
+            raise("Can't parse JSON from dry run:\n#{content}")
+          end
+        end
+        result
+      end
+
+      def cucumber_config_file
+        Dir.glob('{,.config/,config/}cucumber{.yml,.yaml}').first
+      end
+
+      def expand_profiles(cucumber_options)
+        config = YAML.load(ERB.new(File.read(cucumber_config_file)).result)
+        _expand_profiles(cucumber_options, config)
+      end
+
+      def _expand_profiles(options, config)
+        expand_next = false
+        options.split.map do |option|
+          case
+            when %w(-p --profile).include?(option)
+              expand_next = true
+              next
+            when expand_next
+              expand_next = false
+              _expand_profiles(config[option], config)
+            else
+              option
+          end
+        end.compact.join(' ')
+      end
+
+      def group_creator(groups_count, tasks)
+        groups = Array.new(groups_count) { [] }
+
+        tasks.each do |task|
+          group = groups.min_by(&:size)
+          group.push(task)
+        end
+        groups.reject(&:empty?).map(&:compact)
+      end
+    end # class
+  end # Grouper
+end # ParallelCucumber

data/lib/parallel_cucumber/result_formatter.rb

@@ -0,0 +1,72 @@
+module ParallelCucumber
+  class ResultFormatter
+    class << self
+      def report_results(test_results)
+        results = find_results(test_results.map { |result| result[:stdout] }.join(''))
+        puts ''
+        puts summarize_results(results)
+      end
+
+      def find_results(test_output)
+        test_output.split("\n").map do |line|
+          line.gsub!(/\e\[\d+m/, '')
+          next unless line_is_result?(line)
+          line
+        end.compact
+      end
+
+      def line_is_result?(line)
+        line =~ scenario_or_step_result_regex || line =~ failing_scenario_regex
+      end
+
+      def summarize_results(results)
+        output = ["\n\n************ FINAL SUMMARY ************"]
+
+        failing_scenarios = results.grep(failing_scenario_regex)
+        if failing_scenarios.any?
+          failing_scenarios.unshift('Failing Scenarios:')
+          output << failing_scenarios.join("\n")
+        end
+
+        output << summary(results)
+
+        output.join("\n\n")
+      end
+
+      def summary(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 && number != 1
+            "#{number} #{word}#{plural}"
+          end
+          "#{sums[0]} (#{sums[1..-1].join(', ')})"
+        end.compact.join("\n")
+      end
+
+      def sum_up_results(results)
+        results = results.join(' ').gsub(/s\b/, '') # combine and singularize results
+        counts = results.scan(/(\d+) (\w+)/)
+        counts.each_with_object(Hash.new(0)) do |(number, word), sum|
+          sum[word] += number.to_i
+        end
+      end
+
+      private
+
+      def scenario_or_step_result_regex
+        /^\d+ (steps?|scenarios?)/
+      end
+
+      def failing_scenario_regex
+        %r{^cucumber .*features/.+:\d+}
+      end
+    end # class
+  end # ResultFormatter
+end # ParallelCucumber

data/lib/parallel_cucumber/runner.rb

@@ -0,0 +1,121 @@
+require 'English'
+
+module ParallelCucumber
+  class Runner
+    def initialize(options)
+      @options = options
+    end
+
+    def run_tests(process_number, cucumber_args)
+      cmd = command_for_test(process_number, cucumber_args)
+      execute_command_for_process(process_number, cmd)
+    end
+
+    private
+
+    def command_for_test(process_number, cucumber_args)
+      thread_delay = @options[:thread_delay]
+      cucumber_options = @options[:cucumber_options]
+      setup_script = @options[:setup_script]
+      teardown_script = @options[:teardown_script]
+
+      delay_cmd = thread_delay > 0 ? "sleep #{thread_delay * process_number}" : nil
+
+      cucumber_cmd = ['cucumber', cucumber_options, *cucumber_args].compact.join(' ')
+
+      cmd = [delay_cmd, setup_script, cucumber_cmd].compact.join(' && ')
+      teardown_script.nil? ? cmd : "#{cmd}; RET=$?; #{teardown_script}; exit ${RET}"
+    end
+
+    def execute_command_for_process(process_number, cmd)
+      env = env_for_process(process_number)
+      print_chevron_msg(process_number, "Custom env: #{env.map { |k, v| "#{k}=#{v}" }.join(' ')}; command: #{cmd}")
+
+      begin
+        output = IO.popen(env, "#{cmd} 2>&1") do |io|
+          print_chevron_msg(process_number, "Pid: #{io.pid}")
+          show_output(io, process_number)
+        end
+      ensure
+        exit_status = -1
+        if !$CHILD_STATUS.nil? && $CHILD_STATUS.exited?
+          exit_status = $CHILD_STATUS.exitstatus
+          print_chevron_msg(process_number, "Exited with status #{exit_status}")
+        end
+      end
+
+      { stdout: output, exit_status: exit_status }
+    end
+
+    def env_for_process(process_number)
+      env_variables = @options[:env_variables]
+      env = env_variables.map do |k, v|
+        case v
+        when String, Numeric, TrueClass, FalseClass
+          [k, v]
+        when Array
+          [k, v[process_number]]
+        when Hash
+          value = v[process_number.to_s]
+          [k, value] unless value.nil?
+        when NilClass
+        else
+          fail("Don't know how to set '#{v}'(#{v.class}) to the environment variable '#{k}'")
+        end
+      end.compact.to_h
+
+      {
+        TEST: 1,
+        TEST_PROCESS_NUMBER: process_number
+      }.merge(env).map { |k, v| [k.to_s, v.to_s] }.to_h
+    end
+
+    def print_chevron_msg(chevron, line, io = $stdout)
+      msg = "#{chevron}> #{line}\n"
+      io.print(msg)
+      io.flush
+    end
+
+    def show_output(io, process_number)
+      file = File.open("process_#{process_number}.log", 'w')
+      remaining_part = ''
+      probable_finish = false
+      begin
+        loop do
+          text_block = remaining_part + io.read_nonblock(32 * 1024)
+          lines = text_block.split("\n")
+          remaining_part = lines.pop
+          probable_finish = last_cucumber_line?(remaining_part)
+          lines.each do |line|
+            probable_finish = true if last_cucumber_line?(line)
+            print_chevron_msg(process_number, line)
+            file.write("#{line}\n")
+          end
+        end
+      rescue IO::WaitReadable
+        timeout = probable_finish ? 10 : 1800
+        result = IO.select([io], [], [], timeout)
+        if result.nil?
+          if probable_finish
+            print_chevron_msg(process_number,
+                              "Timeout reached in #{timeout}s, but process has probably finished", $stderr)
+          else
+            raise("Read timeout has reached for process #{process_number}. There is no output in #{timeout}s")
+          end
+        else
+          retry
+        end
+      rescue EOFError # rubocop:disable Lint/HandleExceptions
+      ensure
+        print_chevron_msg(process_number, remaining_part)
+        file.write(remaining_part.to_s)
+        file.close unless file.nil?
+      end
+      File.read("process_#{process_number}.log")
+    end
+
+    def last_cucumber_line?(line)
+      !(line =~ /\d+m[\d\.]+s/).nil?
+    end
+  end # Runner
+end # ParallelCucumber

data/lib/parallel_cucumber/version.rb

@@ -0,0 +1,3 @@
+module ParallelCucumber
+  VERSION = '0.1.22'.freeze
+end # ParallelCucumber

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: parallel_cucumber
+version: !ruby/object:Gem::Version
+  version: 0.1.22
+platform: ruby
+authors:
+- Alexander Bayandin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-01-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: parallel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.36'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.36'
+description: 
+email: a.bayandin@gmail.com
+executables:
+- parallel_cucumber
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/parallel_cucumber
+- lib/parallel_cucumber.rb
+- lib/parallel_cucumber/cli.rb
+- lib/parallel_cucumber/grouper.rb
+- lib/parallel_cucumber/result_formatter.rb
+- lib/parallel_cucumber/runner.rb
+- lib/parallel_cucumber/version.rb
+homepage: https://github.com/bayandin/parallel_cucumber
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Run cucumber in parallel
+test_files: []
+has_rdoc: