parallel_cucumber 0.2.18 → 0.2.23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 910908ef4d933b4914d5ea9872946844feaf4755fde1e33e1739438ed2bca2d5
-  data.tar.gz: 0cc6af7cd57aa6c29525514a497ecfdd82df69536782e383c36fbd47851c50fe
+  metadata.gz: 9bb333397a44aa5a42a0ab3fd0b2ff757727eb9fc63bb01960ad1a6d92f7d40e
+  data.tar.gz: 7615b9ececcb23e8e8ce863e1bc77a021a28f14cfadd710bbc9e5a7b7d68c329
 SHA512:
-  metadata.gz: 4a5f7ea51c8407311ad96825e829e6a823cb6e7a6db37bc498c9f785485153d18f43dd616b0d351e69bdc869437603267edbc02de69ad90ddb26bec30422354f
-  data.tar.gz: 77878547532ac93709d73e5eab115fadb56deb6709b0a13716fd020e04643e359eed868bc10ba3313c1893ffd94e6e7e6419040813ee420dba59a3cff72aeef1
+  metadata.gz: 969b2a5e2dafad3fd558ba5e0cfc9ea0cbb7f2510c8ecb3d968668490b9b86319c123447989998f3e4370a45153e8b13c1eabe6060457955d264dda81e3c5b74
+  data.tar.gz: 2065449df4c9997df9f9e19bbbedebe8b64679d307fe91b4e4ce4106e82b8270a51e13d8706976a3caaa1cb2b85f8aacf9eee178e7b31cc91f6fa059db2e135d

data/lib/parallel_cucumber/cli.rb

@@ -8,7 +8,6 @@ module ParallelCucumber
       batch_size: 1,
       batch_timeout: 600,
       setup_timeout: 30,
-      precheck_timeout: 30,
       batch_error_timeout: 30,
       cucumber_options: '',
       debug: false,
@@ -90,10 +89,6 @@ module ParallelCucumber
           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
-
         opts.on('--log-dir DIR', 'Directory for worker logfiles') do |log_dir|
           options[:log_dir] = log_dir
         end
@@ -173,13 +168,6 @@ module ParallelCucumber
           options[:batch_timeout] = batch_timeout
         end
 
-        help_message = <<-TEXT.gsub(/\s+/, ' ').strip
-          Timeout for each test precheck. Default is #{DEFAULTS[:batch_timeout]}
-        TEXT
-        opts.on('--precheck-timeout SECONDS', Float, help_message) do |timeout|
-          options[:precheck_timeout] = timeout
-        end
-
         help_message = <<-TEXT.gsub(/\s+/, ' ').strip
           Timeout for each batch_error script. Default is #{DEFAULTS[:batch_error_timeout]}
         TEXT

data/lib/parallel_cucumber/dsl.rb

@@ -23,6 +23,10 @@ module ParallelCucumber
         Hooks.register_after_batch(proc)
       end
 
+      def worker_health_check(&proc)
+        Hooks.register_worker_health_check(proc)
+      end
+
       def before_workers(&proc)
         Hooks.register_before_workers(proc)
       end
@@ -34,6 +38,10 @@ module ParallelCucumber
       def on_batch_error(&proc)
         Hooks.register_on_batch_error(proc)
       end
+
+      def on_dry_run_error(&proc)
+        Hooks.register_on_dry_run_error(proc)
+      end
     end
   end
 end

data/lib/parallel_cucumber/helper/command.rb

@@ -15,8 +15,13 @@ module ParallelCucumber
         end
 
         ONE_SECOND = 1
+        STACKTRACE_COLLECTION_TIMEOUT = 10
 
-        def exec_command(env, desc, script, logger, log_decoration = {}, timeout: 30, capture: false, return_script_error: false) # rubocop:disable Metrics/ParameterLists, Metrics/LineLength
+        # rubocop:disable Metrics/ParameterLists, Metrics/LineLength
+        def exec_command(env, desc, script, logger, log_decoration = {},
+                         timeout: 30, capture: false, return_script_error: false,
+                         return_on_timeout: false, collect_stacktrace: false
+        )
           block_name = ''
           if log_decoration['worker_block']
             if log_decoration['start'] || log_decoration['end']
@@ -28,42 +33,48 @@ module ParallelCucumber
           full_script = "#{script} 2>&1"
           env_string = env.map { |k, v| "#{k}=#{v}" }.sort.join(' ')
           logger << "== Running command `#{full_script}` at #{Time.now}\n== with environment variables: #{env_string}\n"
-          pstat = nil
+          wait_thread = nil
           pout = nil
           capture &&= [''] # Pass by reference
           exception = nil
+          command_pid = nil
 
           begin
             completed = begin
-              pin, pout, pstat = Open3.popen2e(env, full_script)
-              logger << "Command has pid #{pstat[:pid]}\n"
+              pin, pout, wait_thread = Open3.popen2e(env, full_script)
+              command_pid = wait_thread[:pid].to_s
+              logger << "Command has pid #{command_pid}\n"
               pin.close
               out_reader = Thread.new do
-                output_reader(pout, pstat, logger, capture)
+                output_reader(pout, wait_thread, logger, capture)
               end
 
               unless out_reader.join(timeout)
                 raise TimedOutError
               end
 
-              graceful_process_shutdown(out_reader, pstat, pout, logger)
+              graceful_process_shutdown(out_reader, wait_thread, pout, logger)
 
-              pstat.value # reap already-terminated child.
-              "Command completed #{pstat.value} at #{Time.now}"
+              wait_thread.value # reap already-terminated child.
+              "Command completed #{wait_thread.value} at #{Time.now}"
             end
 
             logger << "#{completed}\n"
 
-            raise "Script returned #{pstat.value.exitstatus}" unless pstat.value.success? || return_script_error
+            raise "Script returned #{wait_thread.value.exitstatus}" unless wait_thread.value.success? || return_script_error
 
             capture_or_empty = capture ? capture.first : '' # Even '' is truthy
-            return pstat.value.success? ? capture_or_empty : nil
+            return wait_thread.value.success? ? capture_or_empty : nil
           rescue TimedOutError => e
-            force_kill_process_with_tree(out_reader, pstat, pout, full_script, logger, timeout)
+            process_tree = Helper::Processes.ps_tree
+            send_usr1_to_process_with_tree(command_pid, full_script, logger, process_tree) if collect_stacktrace
+            force_kill_process_with_tree(out_reader, wait_thread, pout, full_script, logger, timeout, process_tree, command_pid)
+
+            return capture.first if return_on_timeout
 
             exception = e
           rescue => e
-            logger.debug("Exception #{pstat ? pstat[:pid] : "pstat=#{pstat}=nil"}")
+            logger.debug("Exception #{wait_thread ? wait_thread[:pid] : "wait_thread=#{wait_thread}=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}")
 
@@ -75,6 +86,7 @@ module ParallelCucumber
 
           raise exception
         end
+        # rubocop:enable Metrics/ParameterLists, Metrics/LineLength
 
         def log_until_incomplete_line(logger, out_string)
           loop do
@@ -87,13 +99,13 @@ module ParallelCucumber
 
         private
 
-        def output_reader(pout, pstat, logger, capture)
+        def output_reader(pout, wait_thread, logger, capture)
           out_string = ''
 
           loop do
             io_select = IO.select([pout], [], [], ONE_SECOND)
-            unless io_select || pstat.alive?
-              logger << "\n== Terminating because io_select=#{io_select} when pstat.alive?=#{pstat.alive?}\n"
+            unless io_select || wait_thread.alive?
+              logger << "\n== Terminating because io_select=#{io_select} when wait_thread.alive?=#{wait_thread.alive?}\n"
               break
             end
             next unless io_select
@@ -103,44 +115,45 @@ module ParallelCucumber
             out_string = log_until_incomplete_line(logger, out_string + partial)
           end
         rescue EOFError
-          logger << "\n== EOF is normal exit, #{pstat.inspect}\n"
+          logger << "\n== EOF is normal exit, #{wait_thread.inspect}\n"
         rescue => e
           logger << "\n== Exception in out_reader due to #{e.inspect} #{e.backtrace}\n"
         ensure
           logger << out_string
           logger << ["\n== Left out_reader at #{Time.now}; ",
-                     "pipe=#{pstat.status}+#{pstat.status ? '≤no value≥' : pstat.value}\n"].join
+                     "pipe=#{wait_thread.status}+#{wait_thread.status ? '≤no value≥' : wait_thread.value}\n"].join
         end
 
-        def graceful_process_shutdown(out_reader, pstat, pout, logger)
-          out_reader.value # Should terminate with pstat
+        def graceful_process_shutdown(out_reader, wait_thread, pout, logger)
+          out_reader.value # Should terminate with wait_thread
           pout.close
-          if pstat.status
-            logger << "== Thread #{pstat.inspect} is not dead"
+          if wait_thread.status
+            logger << "== Thread #{wait_thread.inspect} is not dead"
 
-            if pstat.join(3)
-              logger << "== Thread #{pstat.inspect} joined late"
+            if wait_thread.join(3)
+              logger << "== Thread #{wait_thread.inspect} joined late"
             else
-              pstat.terminate # Just in case
-              logger << "== Thread #{pstat.inspect} terminated"
+              wait_thread.terminate # Just in case
+              logger << "== Thread #{wait_thread.inspect} terminated"
             end # Make an effort to reap
           end
 
-          pstat.value # reap already-terminated child.
-          "Command completed #{pstat.value} at #{Time.now}"
+          wait_thread.value # reap already-terminated child.
+          "Command completed #{wait_thread.value} at #{Time.now}"
         end
 
-        def force_kill_process_with_tree(out_reader, pstat, pout, full_script, logger, timeout) # rubocop:disable Metrics/ParameterLists, Metrics/LineLength
+        def send_usr1_to_process_with_tree(command_pid, full_script, logger, tree)
+          return if Helper::Processes.ms_windows?
+
+          logger << "Timeout, so trying SIGUSR1 to trigger watchdog stacktrace #{command_pid}=#{full_script}"
+          Helper::Processes.kill_tree('SIGUSR1', command_pid, logger, tree)
+          sleep(STACKTRACE_COLLECTION_TIMEOUT) # Wait enough time for child processes to act on SIGUSR1
+        end
+
+        def force_kill_process_with_tree(out_reader, wait_thread, pout, full_script, logger, timeout, tree, pid) # rubocop:disable Metrics/ParameterLists, Metrics/LineLength
           out_reader.exit
-          tree = Helper::Processes.ps_tree
-          pid = pstat[:pid].to_s
-          unless Helper::Processes.ms_windows?
-            logger << "Timeout, so trying SIGUSR1 to trigger watchdog stacktrace #{pstat[:pid]}=#{full_script}"
-            Helper::Processes.kill_tree('SIGUSR1', pid, logger, tree)
-            sleep 2
-          end
 
-          logger << "Timeout, so trying SIGINT at #{pstat[:pid]}=#{full_script}"
+          logger << "Timeout, so trying SIGINT at #{wait_thread[:pid]}=#{full_script}"
 
           log_copy = Thread.new do
             pout.each_line { |l| logger << l }
@@ -167,7 +180,7 @@ module ParallelCucumber
             end
 
             logger << "About to reap root #{pid}"
-            pstat.value # reap root - everything else should be reaped by init.
+            wait_thread.value # reap root - everything else should be reaped by init.
             logger << "Reaped root #{pid}"
           end
         end

data/lib/parallel_cucumber/helper/cucumber/cucumber.rb

@@ -26,25 +26,32 @@ module ParallelCucumber
 
         def parse_json_report(json_report)
           report = JSON.parse(json_report, symbolize_names: true)
-          report.map do |scenario, cucumber_status|
-            status = case cucumber_status
-                       when 'failed'
-                         Status::FAILED
-                       when 'passed'
-                         Status::PASSED
-                       when 'pending'
-                         Status::PENDING
-                       when 'skipped'
-                         Status::SKIPPED
-                       when 'undefined'
-                         Status::UNDEFINED
-                       when 'unknown'
-                         Status::UNKNOWN
-                       else
-                         Status::UNKNOWN
-                     end
-            [scenario, status]
-          end.to_h
+          report.each do |scenario, details|
+            report[scenario][:status] = case details[:status]
+                                        when 'failed'
+                                          Status::FAILED
+                                        when 'passed'
+                                          Status::PASSED
+                                        when 'pending'
+                                          Status::PENDING
+                                        when 'skipped'
+                                          Status::SKIPPED
+                                        when 'undefined'
+                                          Status::UNDEFINED
+                                        when 'unknown'
+                                          Status::UNKNOWN
+                                        else
+                                          Status::UNKNOWN
+                                        end
+          end
+          report
+        end
+
+        def unknown_result(tests)
+          res = tests.map do |test|
+            [test.to_sym, {status: ::ParallelCucumber::Status::UNKNOWN}]
+          end
+          res.to_h
         end
 
         private
@@ -57,7 +64,7 @@ module ParallelCucumber
           options = remove_strict_flag(options)
           content = nil
 
-          Tempfile.open(%w(dry-run .json)) do |f|
+          Tempfile.open(%w[dry-run .json]) do |f|
             dry_run_options = "--dry-run --format ParallelCucumber::Helper::Cucumber::JsonStatusFormatter --out #{f.path}"
 
             cmd = "cucumber #{options} #{dry_run_options} #{args_string}"

data/lib/parallel_cucumber/helper/cucumber/json_status_formatter.rb

@@ -15,7 +15,13 @@ module ParallelCucumber
         end
 
         def on_after_test_case(event)
-          @result[event.test_case.location.to_s] = event.result.to_sym
+          details = {status: event.result.to_sym}
+          if event.result.respond_to?(:exception)
+            details[:exception_classname] = event.result.exception.class.to_s
+            details[:exception_message] = event.result.exception.message
+          end
+          details[:finish_time] = Time.now.to_i
+          @result[event.test_case.location.to_s] = details
         end
 
         def on_finished_testing(*)

data/lib/parallel_cucumber/helper/processes.rb

@@ -35,7 +35,7 @@ module ParallelCucumber
           else
             descendants(root, logger, tree, old_tree, 'kill') do |pid, node|
               begin
-                logger.warn "Killing #{node}"
+                logger.warn "Sending signal #{sig} to #{node}"
                 Process.kill(sig, pid.to_i)
               rescue Errno::ESRCH
                 nil # It's gone already? Hurrah!
@@ -44,7 +44,7 @@ module ParallelCucumber
           end
           # Let's kill pid unconditionally: descendants will go astray once reparented.
           begin
-            logger.warn "Killing #{root} just in case"
+            logger.warn "Sending signal #{sig} to root process #{root} just in case"
             Process.kill(sig, root.to_i)
           rescue Errno::ESRCH
             nil # It's gone already? Hurrah!

data/lib/parallel_cucumber/hooks.rb

@@ -1,12 +1,19 @@
 module ParallelCucumber
   class Hooks
-    @before_batch_hooks ||= []
-    @after_batch_hooks  ||= []
-    @before_workers     ||= []
-    @after_workers      ||= []
-    @on_batch_error     ||= []
+    @worker_health_check ||= []
+    @before_batch_hooks  ||= []
+    @after_batch_hooks   ||= []
+    @before_workers      ||= []
+    @after_workers       ||= []
+    @on_batch_error      ||= []
+    @on_dry_run_error    ||= []
 
     class << self
+      def register_worker_health_check(proc)
+        raise(ArgumentError, 'Please provide a valid callback') unless proc.respond_to?(:call)
+        @worker_health_check << proc
+      end
+
       def register_before_batch(proc)
         raise(ArgumentError, 'Please provide a valid callback') unless proc.respond_to?(:call)
         @before_batch_hooks << proc
@@ -32,6 +39,17 @@ module ParallelCucumber
         @on_batch_error << proc
       end
 
+      def register_on_dry_run_error(proc)
+        raise(ArgumentError, 'Please provide a valid callback') unless proc.respond_to?(:call)
+        @on_dry_run_error << proc
+      end
+
+      def fire_worker_health_check(*args)
+        @worker_health_check.each do |hook|
+          hook.call(*args)
+        end
+      end
+
       def fire_before_batch_hooks(*args)
         @before_batch_hooks.each do |hook|
           hook.call(*args)
@@ -61,6 +79,12 @@ module ParallelCucumber
           hook.call(*args)
         end
       end
+
+      def fire_on_dry_run_error(error)
+        @on_dry_run_error.each do |hook|
+          hook.call(error)
+        end
+      end
     end
   end
 end

data/lib/parallel_cucumber/main.rb

@@ -30,8 +30,12 @@ module ParallelCucumber
         exit(1)
       end
 
-      all_tests = Helper::Cucumber.selected_tests(@options[:cucumber_options], @options[:cucumber_args])
-
+      begin
+        all_tests = Helper::Cucumber.selected_tests(@options[:cucumber_options], @options[:cucumber_args])
+      rescue StandardError => error
+        Hooks.fire_on_dry_run_error(error)
+        raise error
+      end
       if all_tests.empty?
         @logger.info('There is no tests to run, exiting...')
         exit(0)
@@ -98,7 +102,7 @@ module ParallelCucumber
 
         status_totals = Status.constants.map do |status|
           status = Status.const_get(status)
-          tests_with_status = results.select { |_t, s| s == status }.keys
+          tests_with_status = results.select { |_t, s| s[:status] == status }.keys
           [status, tests_with_status]
         end.to_h
 

data/lib/parallel_cucumber/version.rb

@@ -1,3 +1,3 @@
 module ParallelCucumber
-  VERSION = '0.2.18'.freeze
+  VERSION = '0.2.23'.freeze
 end

data/lib/parallel_cucumber/worker.rb

@@ -10,11 +10,9 @@ module ParallelCucumber
       @group_by = options[:group_by]
       @batch_timeout = options[:batch_timeout]
       @batch_error_timeout = options[:batch_error_timeout]
-      @precheck_timeout = options[:precheck_timeout]
       @setup_timeout = options[:setup_timeout]
       @cucumber_options = options[:cucumber_options]
       @test_command = options[:test_command]
-      @pre_check = options[:pre_check]
       @index = index
       @name = "W#{@index}"
       @setup_worker = options[:setup_worker]
@@ -99,12 +97,7 @@ module ParallelCucumber
               job = @jobs_queue.pop(false)
               case job.type
               when Job::PRECHECK
-                precmd = precheck(env)
-                if (m = precmd.match(/precmd:retry-after-(\d+)-seconds/))
-                  @manager.inform_idle(@name)
-                  sleep(1 + m[1].to_i)
-                  next
-                end
+                Hooks.fire_worker_health_check(env)
                 @manager.inform_healthy(@name)
               when Job::RUN_TESTS
                 run_batch(env, results, running_total, job.details)
@@ -161,22 +154,10 @@ module ParallelCucumber
       @logger.update_into(@stdout_logger)
     end
 
-    def precheck(env)
-      return 'default no-op pre_check' unless @pre_check
-      begin
-        return Helper::Command.exec_command(
-          env, 'precheck', @pre_check, @logger, @log_decoration, timeout: @precheck_timeout, capture: true
-        )
-      rescue
-        @logger.error('Pre-check failed: quitting immediately')
-        raise 'Pre-check failed: quitting immediately'
-      end
-    end
-
     def running_totals(batch_results, running_total)
       batch_info = Status.constants.map do |status|
         status = Status.const_get(status)
-        [status, batch_results.select { |_t, s| s == status }.keys]
+        [status, batch_results.select { |_t, s| s[:status] == status }.keys]
       end.to_h
       batch_info.each do |s, tt|
         @logger.info("#{s.to_s.upcase} #{tt.count} tests: #{tt.join(' ')}") unless tt.empty?
@@ -191,7 +172,7 @@ module ParallelCucumber
       test_syms = tests.map(&:to_sym)
       unrun = test_syms - batch_keys
       surfeit = batch_keys - test_syms
-      unrun.each { |test| batch_results[test] = Status::UNKNOWN }
+      unrun.each { |test| batch_results[test][:status] = Status::UNKNOWN }
       surfeit.each { |test| batch_results.delete(test) }
       @logger.error("Did not run #{unrun.count}/#{tests.count}: #{unrun.join(' ')}") unless unrun.empty?
       @logger.error("Extraneous runs (#{surfeit.count}): #{surfeit.join(' ')}") unless surfeit.empty?
@@ -220,7 +201,8 @@ module ParallelCucumber
       begin
         ParallelCucumber::Helper::Command.exec_command(
           batch_env, 'batch', mapped_batch_cmd, @logger, @log_decoration,
-          timeout: @batch_timeout, return_script_error: true
+          timeout: @batch_timeout, capture: true, return_script_error: true,
+          return_on_timeout: true, collect_stacktrace: true
         )
       rescue => e
         @logger << "ERROR #{e} #{e.backtrace.first(5)}"
@@ -232,7 +214,7 @@ module ParallelCucumber
           @logger.warn("There was exception in on_batch_error hook #{exc.message} \n #{trace}")
         end
 
-        return tests.map { |t| [t, ::ParallelCucumber::Status::UNKNOWN] }.to_h
+        return Helper::Cucumber.unknown_result(tests)
       end
       parse_results(test_state, tests)
     ensure
@@ -291,18 +273,18 @@ module ParallelCucumber
     def parse_results(f, tests)
       unless File.file?(f)
         @logger.error("Results file does not exist: #{f}")
-        return tests.map { |t| [t, ::ParallelCucumber::Status::UNKNOWN] }.to_h
+        return Helper::Cucumber.unknown_result(tests)
       end
       json_report = File.read(f)
       if json_report.empty?
         @logger.error("Results file is empty: #{f}")
-        return tests.map { |t| [t, ::ParallelCucumber::Status::UNKNOWN] }.to_h
+        return Helper::Cucumber.unknown_result(tests)
       end
       Helper::Cucumber.parse_json_report(json_report)
     rescue => e
       trace = e.backtrace.join("\n\t").sub("\n\t", ": #{$ERROR_INFO}#{e.class ? " (#{e.class})" : ''}\n\t")
       @logger.error("Threw: JSON parse of results caused #{trace}")
-      tests.map { |t| [t, ::ParallelCucumber::Status::UNKNOWN] }.to_h
+      Helper::Cucumber.unknown_result(tests)
     end
   end
 end

data/lib/parallel_cucumber/worker_manager.rb

@@ -39,7 +39,7 @@ module ParallelCucumber
     def create_workers(number_of_workers)
       number_of_workers.times do |index|
         @workers["W#{index}"] =
-            ParallelCucumber::Worker.new(options: @options, index: index, stdout_logger: @logger, manager: self)
+          ParallelCucumber::Worker.new(options: @options, index: index, stdout_logger: @logger, manager: self)
       end
     end
 
@@ -67,11 +67,15 @@ module ParallelCucumber
         puts "Starting W#{index}"
         @workers["W#{index}"].start(env_for_worker(@options[:env_variables], index))
       end
-      @results.inject(:merge) # Returns hash of file:line to statuses + :worker-index to summary.
+      @results.inject do |seed, result|
+        seed.merge(result) do |_key, oldval, newval|
+          (newval[:finish_time] > oldval[:finish_time]) ? newval : oldval
+        end
+      end
     end
 
     def kill_all_workers
-      @logger.info("=== Killing All Workers")
+      @logger.info('=== Killing All Workers')
       @workers.values.each { |w| w.assign_job(Job.new(Job::DIE)) }
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parallel_cucumber
 version: !ruby/object:Gem::Version
-  version: 0.2.18
+  version: 0.2.23
 platform: ruby
 authors:
 - Alexander Bayandin
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-11-29 00:00:00.000000000 Z
+date: 2020-12-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cucumber
@@ -72,14 +72,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.59.2
+        version: 0.73.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.59.2
+        version: 0.73.0
 description: Our own parallel cucumber with queue and workers
 email: a.bayandin@gmail.com
 executables:
@@ -112,7 +112,7 @@ homepage: https://github.com/badoo/parallel_cucumber
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -127,8 +127,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.4
-signing_key: 
+rubygems_version: 3.0.8
+signing_key:
 specification_version: 4
 summary: Run cucumber in parallel
 test_files: []