parallel_cucumber 0.1.22 → 0.2.0.pre.36

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0712cec043620fc781e38673adc438452b993e59
-  data.tar.gz: a8c396bf23c857e9f269e36ea24b018b304de8c4
+  metadata.gz: 9a409cddb7ad8882664b62866dd1d9ffb39caa9d
+  data.tar.gz: 0224ea5dd38f661176160e0534f1b5c673f9d147
 SHA512:
-  metadata.gz: 2561568ca2d8397944b67171a49839832b422d16135c21b749ca27965706c99165358f520f79f4464724e58978598b07901cc95c298a1a207661fd5fdbc325aa
-  data.tar.gz: 024e7fe7d1c6427080e94a7f572b3b45c3c940224dea48b956085b5be876107408970004953116f00f92d9b884ab2e2f6920d00df81fe003f6a8ecbe181dd91d
+  metadata.gz: 155b9bd2377687099c769731f2cf576d4e8984883745adadc08a48ac6403ea0f6e779714c0ade86b2dc816f469733ce78cb22c7826b195c6aed74df7fb3cca33
+  data.tar.gz: bd51ffc599151b873599bff76353b3c565f878d18262b6d1c981b364eb708ac3fa6e3e89e611987124a56d110337873d0a2b498d07a57a59944033a3bcf9c8e5

data/README.md

@@ -1,15 +1,35 @@
 # Parallel Cucumber
 
+### Usage
+
 ```
 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
+    -n WORKERS                       How many workers to use. Default is 1 or longest list in -e
+    -o, --cucumber-options "OPTIONS" Run cucumber with these options
+        --test-command COMMAND       Command to run for test phase, default cucumber
+        --pre-batch-check COMMAND    Command causing worker to quit on exit failure
+    -e, --env-variables JSON         Set additional environment variables to processes
+        --batch-size SIZE            How many tests each worker takes from queue at once. Default is 1
+    -q ARRAY,                        `url,name` Url for TCP connection: `redis://[password]@[hostname]:[port]/[db]` (password, port and database are optional), for unix socket connection: `unix://[path to Redis socket]`. Default is redis://127.0.0.1:6379 and name is `queue`
+        --queue-connection-params
+        --setup-worker SCRIPT        Execute SCRIPT before each worker
+        --teardown-worker SCRIPT     Execute SCRIPT after each worker
+        --worker-delay SECONDS       Delay before next worker starting. Could be used for avoiding 'spikes' in CPU and RAM usage Default is 0
+        --batch-timeout SECONDS      Timeout for each batch of tests. Default is 600
+        --debug                      Print more debug information
     -v, --version                    Show version
     -h, --help                       Show this
 ```
+
+### Reports
+
+```yaml
+# config/cucumber.yaml
+
+<% test_batch_id = "#{ENV['TEST_BATCH_ID']}" %>
+
+parallel_reports: >
+  --format html --out reports/cukes_<%= test_batch_id %>.html
+  --format junit --out reports/junit_<%= test_batch_id %>/
+```

data/bin/parallel_cucumber

@@ -6,4 +6,4 @@ $LOAD_PATH << "#{root}/lib" if File.exist?("#{root}/Gemfile")
 
 require 'parallel_cucumber'
 
-ParallelCucumber::Cli.run(ARGV)
+ParallelCucumber::Cli.new(ARGV).run

data/lib/parallel_cucumber.rb

@@ -1,53 +1,12 @@
-require 'parallel'
-
 require 'parallel_cucumber/cli'
-require 'parallel_cucumber/grouper'
-require 'parallel_cucumber/result_formatter'
-require 'parallel_cucumber/runner'
+require 'parallel_cucumber/helper/command'
+require 'parallel_cucumber/helper/cucumber'
+require 'parallel_cucumber/helper/multi_delegator'
+require 'parallel_cucumber/helper/processes'
+require 'parallel_cucumber/helper/queue'
+require 'parallel_cucumber/helper/utils'
+require 'parallel_cucumber/logger'
+require 'parallel_cucumber/main'
+require 'parallel_cucumber/status'
 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
+require 'parallel_cucumber/worker'

data/lib/parallel_cucumber/cli.rb

@@ -1,79 +1,186 @@
 require 'json'
 require 'optparse'
+require 'date'
 
 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
+  class Cli
+    DEFAULTS = {
+      batch_size: 1,
+      batch_timeout: 600,
+      setup_timeout: 30,
+      cucumber_options: '',
+      debug: false,
+      log_dir: '.',
+      log_decoration: {},
+      env_variables: {},
+      n: 0, # Default: computed from longest list in json parameters, minimum 1.
+      queue_connection_params: ['redis://127.0.0.1:6379', DateTime.now.strftime('queue-%Y%m%d%H%M%S')],
+      worker_delay: 0,
+      test_command: 'cucumber'
+    }.freeze
 
-      private
+    def initialize(argv)
+      @argv = argv
+      @logger = ParallelCucumber::CustomLogger.new(STDOUT)
+      @logger.progname = 'CLI'
+      @logger.level = if @argv.include?('--debug')
+                        ParallelCucumber::CustomLogger::DEBUG
+                      else
+                        ParallelCucumber::CustomLogger::INFO
+                      end
+    end
 
-      def parse_options!(argv)
-        options = DEFAULTS.dup
+    def run
+      options = parse_options!(@argv)
+      message = <<-LOG
+          Running parallel_cucumber with options: #{options.map { |k, v| "#{k}=#{v}" }.join(', ')}
+      LOG
+      @logger.debug(message)
+      ParallelCucumber::Main.new(options).run
+    end
 
-        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)
+    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 WORKERS', Integer, 'How many workers to use. Default is 1 or longest list in -e') do |n|
+          if n < 1
+            puts "The minimum number of processes is 1 but given: '#{n}'"
+            exit 1
           end
-          opts.on('-t', '--teardown-script [SCRIPT]', 'Execute SCRIPT after each process') do |script|
-            check_script(script)
-            options[:teardown_script] = File.expand_path(script)
+          options[:n] = n
+        end
+
+        opts.on('-o', '--cucumber-options "OPTIONS"', 'Run cucumber with these options') do |cucumber_options|
+          options[:cucumber_options] = cucumber_options
+        end
+
+        opts.on('--test-command COMMAND',
+                "Command to run for test phase, default #{DEFAULTS[:test_command]}") do |test_command|
+          options[:test_command] = test_command
+        end
+
+        opts.on('--pre-batch-check COMMAND', 'Command causing worker to quit on exit failure') do |pre_check|
+          options[:pre_check] = pre_check
+        end
+
+        options[:pretty] = '--format pretty'
+        opts.on('--no-pretty', "Suppress the default 'pretty' formatter directed at stdout") do
+          options[:pretty] = ''
+        end
+
+        opts.on('--log-dir DIR', 'Directory for worker logfiles') do |log_dir|
+          options[:log_dir] = log_dir
+        end
+
+        opts.on('--log-decoration JSON', 'Block quoting for logs, e.g. {start: "#start %s", end: "#end %s"}') do |json|
+          options[:log_decoration] = begin
+            JSON.parse(json)
+          rescue JSON::ParserError
+            puts 'Log block quoting not in JSON format. Did you forget to escape the quotes?'
+            raise
           end
-          opts.on('--thread-delay [SECONDS]', Float, 'Delay before next thread starting') do |thread_delay|
-            options[:thread_delay] = thread_delay
+        end
+
+        opts.on('--summary JSON', 'Summary files, e.g. {failed: "./failed.txt", unknown: "./unknown.txt"}') do |json|
+          options[:summary] = begin
+            JSON.parse(json)
+          rescue JSON::ParserError
+            puts 'Log block quoting not in JSON format. Did you forget to escape the quotes?'
+            raise
           end
-          opts.on('-v', '--version', 'Show version') do
-            puts ParallelCucumber::VERSION
-            exit 0
+        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. Did you forget to escape the quotes?'
+            raise
           end
-          opts.on('-h', '--help', 'Show this') do
-            puts opts
-            exit 0
+        end
+
+        help_message = "How many tests each worker takes from queue at once. Default is #{DEFAULTS[:batch_size]}"
+        opts.on('--batch-size SIZE', Integer, help_message.gsub(/\s+/, ' ').strip) do |batch_size|
+          if batch_size < 1
+            puts "The minimum batch size is 1 but given: '#{batch_size}'"
+            exit 1
           end
+          options[:batch_size] = batch_size
         end
 
-        option_parser.parse!(argv)
-        options[:cucumber_args] = argv
+        help_message = <<-TEXT
+         `url,name`
+          Url for TCP connection:
+          `redis://[password]@[hostname]:[port]/[db]` (password, port and database are optional),
+          for unix socket connection: `unix://[path to Redis socket]`.
+          Default is redis://127.0.0.1:6379 and name is `queue`
+        TEXT
+        opts.on('-q', '--queue-connection-params ARRAY', Array, help_message.gsub(/\s+/, ' ').strip) do |params|
+          options[:queue_connection_params] = params
+        end
 
-        options
-      rescue OptionParser::InvalidOption => e
-        puts "Unknown option #{e}"
-        puts option_parser.help
-        exit 1
-      end
+        opts.on('--setup-worker SCRIPT', 'Execute SCRIPT before each worker') do |script|
+          options[:setup_worker] = script
+        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)
+        opts.on('--teardown-worker SCRIPT', 'Execute SCRIPT after each worker') do |script|
+          options[:teardown_worker] = script
+        end
+
+        help_message = <<-TEXT
+          Delay before next worker starting.
+          Could be used for avoiding 'spikes' in CPU and RAM usage
+          Default is #{DEFAULTS[:worker_delay]}
+        TEXT
+        opts.on('--worker-delay SECONDS', Float, help_message.gsub(/\s+/, ' ').strip) do |worker_delay|
+          options[:worker_delay] = worker_delay
+        end
+
+        help_message = <<-TEXT
+          Timeout for each batch of tests. Default is #{DEFAULTS[:batch_timeout]}
+        TEXT
+        opts.on('--batch-timeout SECONDS', Float, help_message.gsub(/\s+/, ' ').strip) do |batch_timeout|
+          options[:batch_timeout] = batch_timeout
+        end
+
+        help_message = <<-TEXT
+          Timeout for each worker's set-up phase. Default is #{DEFAULTS[:setup_timeout]}
+        TEXT
+        opts.on('--setup-timeout SECONDS', Float, help_message.gsub(/\s+/, ' ').strip) do |setup_timeout|
+          options[:setup_timeout] = setup_timeout
+        end
+
+        opts.on('--debug', 'Print more debug information') do |debug|
+          options[:debug] = debug
+        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
-    end # class
-  end # Cli
-end # ParallelCucumber
+
+      option_parser.parse!(argv)
+      options[:cucumber_args] = argv
+
+      options
+    rescue OptionParser::InvalidOption => e
+      puts "Unknown option #{e}"
+      puts option_parser.help
+      exit 1
+    end
+  end
+end

data/lib/parallel_cucumber/helper/command.rb

@@ -0,0 +1,87 @@
+module ParallelCucumber
+  module Helper
+    module Command
+      class << self
+        def wrap_block(log_decoration, block_name, logger)
+          logger << format(log_decoration['start'] + "\n", block_name) if log_decoration['start']
+          yield
+        ensure
+          logger << format(log_decoration['end'] + "\n", block_name) if log_decoration['end']
+        end
+
+        def exec_command(env, desc, script, log_file, logger, log_decoration = {}, timeout = 30) # rubocop:disable Metrics/ParameterLists, Metrics/LineLength
+          file = File.open(log_file)
+          file.seek(0, File::SEEK_END)
+          full_script = "#{script} >>#{log_file} 2>&1"
+          env_string = env.map { |k, v| "#{k}=#{v}" }.sort.join(' ')
+          message = <<-LOG
+        Running command `#{full_script}` with environment variables: #{env_string}
+          LOG
+          logger.debug(message)
+          pstat = nil
+          pout = nil
+          begin
+            completed = Timeout.timeout(timeout) do
+              pin, pout, pstat = Open3.popen2e(env, full_script)
+              logger.debug("Command has pid #{pstat[:pid]}")
+              pin.close
+              out = pout.readlines.join("\n") # Not expecting anything in 'out' due to redirection, but...
+              pout.close
+              pstat.value # N.B. Await process termination
+              "Command completed #{pstat.value} and expecting '#{out}' to be empty due to redirects"
+            end
+            logger.debug(completed)
+            # system("lsof #{log_file} >> #{log_file} 2>&1")
+            system("ps -axf | grep '#{pstat[:pid]}\\s' >> #{log_file}")
+            return pstat.value.success?
+          rescue Timeout::Error
+            pout.close
+            logger.debug("Timeout, so trying SIGINT #{pstat[:pid]}")
+            wait_sigint = 15
+            logger.error("Timeout #{timeout}s was reached. Sending SIGINT(2), then waiting up to #{wait_sigint}s")
+            tree = Helper::Processes.ps_tree
+            begin
+              Helper::Processes.kill_tree('SIGINT', pstat[:pid].to_s, tree)
+              timed_out = wait_sigint.times do |t|
+                break if Helper::Processes.all_pids_dead?(pstat[:pid].to_s, nil, tree)
+                logger.info("Wait dead #{t}")
+                sleep 1
+              end
+              if timed_out
+                logger.error("Process #{pstat[:pid]} lasted #{wait_sigint}s after SIGINT(2), so SIGKILL(9)! Fatality!")
+                Helper::Processes.kill_tree('SIGKILL', pstat[:pid].to_s, nil, tree)
+              end
+              logger.debug("About to reap root #{pstat[:pid]}")
+              pstat.value # reap root - everything else should be reaped by init.
+              logger.debug("Reaped root #{pstat[:pid]}")
+              # system("lsof #{log_file} >> #{log_file}")
+              logger.debug("Tried SIGKILL #{pstat[:pid]} - hopefully no processes still have #{log_file}!")
+            end
+          rescue => e
+            logger.debug("Exception #{pstat ? pstat[:pid] : "pstat=#{pstat}=nil"}")
+            trace = e.backtrace.join("\n\t").sub("\n\t", ": #{$ERROR_INFO}#{e.class ? " (#{e.class})" : ''}\n\t")
+            logger.error("Threw: for #{full_script}, caused #{trace}")
+          ensure
+            # It's only logging - don't really care if we lose some, though it would be nice if we didn't.
+            if log_decoration['worker_block']
+              prefix = "#{env['TEST_USER']}-w#{env['WORKER_INDEX']}>"
+              block_name = ''
+              if log_decoration['start'] || log_decoration['end']
+                block_name = "#{prefix} #{desc}"
+                prefix = ''
+              end
+              message = ''
+              message << format(log_decoration['start'] + "\n", block_name) if log_decoration['start']
+              message << "#{prefix}#{file.readline}" until file.eof
+              message << format(log_decoration['end'] + "\n", block_name) if log_decoration['end']
+              logger << message
+              file.close
+            end
+          end
+          logger.debug("Unusual termination for command: #{script}")
+          nil
+        end
+      end
+    end
+  end
+end