cucumber 8.0.0 → 9.2.0

data/lib/cucumber/formatter/ansicolor.rb

@@ -3,7 +3,7 @@
 require 'cucumber/platform'
 require 'cucumber/term/ansicolor'
 
-Cucumber::Term::ANSIColor.coloring = false if !$stdout.tty? && !ENV.key?('AUTOTEST')
+Cucumber::Term::ANSIColor.coloring = false unless $stdout.tty?
 
 module Cucumber
   module Formatter
@@ -63,30 +63,24 @@ module Cucumber
     module ANSIColor
       include Cucumber::Term::ANSIColor
 
-      # :stopdoc:
       ALIASES = Hash.new do |h, k|
         next unless k.to_s =~ /(.*)_param/
 
         "#{h[Regexp.last_match(1)]},bold"
       end.merge(
         'undefined' => 'yellow',
-        'pending'   => 'yellow',
-        'flaky'     => 'yellow',
-        'failed'    => 'red',
-        'passed'    => 'green',
-        'outline'   => 'cyan',
-        'skipped'   => 'cyan',
-        'comment'   => 'grey',
-        'tag'       => 'cyan'
+        'pending' => 'yellow',
+        'flaky' => 'yellow',
+        'failed' => 'red',
+        'passed' => 'green',
+        'outline' => 'cyan',
+        'skipped' => 'cyan',
+        'comment' => 'grey',
+        'tag' => 'cyan'
       )
-      # :startdoc:
 
-      # Apply the custom color scheme
-      #
-      # example:
-      #
-      #   apply_custom_colors('passed=white')
-      def apply_custom_colors(colors)
+      # Apply the custom color scheme -> i.e. apply_custom_colors('passed=white')
+      def self.apply_custom_colors(colors)
         colors.split(':').each do |pair|
           a = pair.split('=')
           ALIASES[a[0]] = a[1]
@@ -117,23 +111,21 @@ module Cucumber
         end
       end
 
-      # :stopdoc:
-      def cukes(n)
-        ('(::) ' * n).strip
+      def cukes(amount)
+        ('(::) ' * amount).strip
       end
 
-      def green_cukes(n)
-        blink(green(cukes(n)))
+      def green_cukes(amount)
+        blink(green(cukes(amount)))
       end
 
-      def red_cukes(n)
-        blink(red(cukes(n)))
+      def red_cukes(amount)
+        blink(red(cukes(amount)))
       end
 
-      def yellow_cukes(n)
-        blink(yellow(cukes(n)))
+      def yellow_cukes(amount)
+        blink(yellow(cukes(amount)))
       end
-      # :startdoc:
 
       private
 

data/lib/cucumber/formatter/ast_lookup.rb

@@ -112,16 +112,24 @@ module Cucumber
             if child.respond_to?(:rule) && child.rule
               process_scenario_container(child.rule)
             elsif child.respond_to?(:scenario) && child.scenario
-              child.scenario.steps.each do |step|
-                @lookup_hash[step.location.line] = StepSource.new(:Step, step)
-              end
+              store_scenario_source_steps(child.scenario)
             elsif !child.background.nil?
-              child.background.steps.each do |step|
-                @lookup_hash[step.location.line] = StepSource.new(:Step, step)
-              end
+              store_background_source_steps(child.background)
             end
           end
         end
+
+        def store_scenario_source_steps(scenario)
+          scenario.steps.each do |step|
+            @lookup_hash[step.location.line] = StepSource.new(:Step, step)
+          end
+        end
+
+        def store_background_source_steps(background)
+          background.steps.each do |step|
+            @lookup_hash[step.location.line] = StepSource.new(:Step, step)
+          end
+        end
       end
 
       KeywordSearchNode = Struct.new(:keyword, :previous_node)

data/lib/cucumber/formatter/console.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-# rubocop:disable Metrics/ModuleLength
-
 require 'cucumber/formatter/ansicolor'
 require 'cucumber/formatter/duration'
 require 'cucumber/gherkin/i18n'
@@ -45,10 +43,10 @@ module Cucumber
         format_string(line, status)
       end
 
-      def format_string(o, status)
+      def format_string(input, status)
         fmt = format_for(status)
-        o.to_s.split("\n").map do |line|
-          if Proc == fmt.class
+        input.to_s.split("\n").map do |line|
+          if fmt.instance_of?(Proc)
             fmt.call(line)
           else
             fmt % line
@@ -94,21 +92,21 @@ module Cucumber
         @io.flush
       end
 
-      def print_exception(e, status, indent)
-        string = exception_message_string(e, indent)
+      def print_exception(exception, status, indent)
+        string = exception_message_string(exception, indent)
         @io.puts(format_string(string, status))
       end
 
-      def exception_message_string(e, indent_amount)
-        message = "#{e.message} (#{e.class})".dup.force_encoding('UTF-8')
+      def exception_message_string(exception, indent_amount)
+        message = "#{exception.message} (#{exception.class})".dup.force_encoding('UTF-8')
         message = linebreaks(message, ENV['CUCUMBER_TRUNCATE_OUTPUT'].to_i)
 
-        indent("#{message}\n#{e.backtrace.join("\n")}", indent_amount)
+        indent("#{message}\n#{exception.backtrace.join("\n")}", indent_amount)
       end
 
       # http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/10655
       def linebreaks(msg, max)
-        return msg unless max && max > 0
+        return msg unless max.positive?
 
         msg.gsub(/.{1,#{max}}(?:\s|\Z)/) do
           (Regexp.last_match(0) + 5.chr).gsub(/\n\005/, "\n").gsub(/\005/, "\n")
@@ -171,12 +169,17 @@ module Cucumber
         end
       end
 
-      def attach(src, media_type)
+      def attach(src, media_type, filename)
         return unless media_type == 'text/x.cucumber.log+plain'
         return unless @io
 
         @io.puts
-        @io.puts(format_string(src, :tag))
+        if filename
+          @io.puts("#{filename}: #{format_string(src, :tag)}")
+        else
+          @io.puts(format_string(src, :tag))
+        end
+
         @io.flush
       end
 
@@ -262,4 +265,3 @@ module Cucumber
     end
   end
 end
-# rubocop:enable Metrics/ModuleLength

data/lib/cucumber/formatter/console_counts.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'cucumber/formatter/console'
 
 module Cucumber
@@ -30,7 +32,7 @@ module Cucumber
 
       def status_counts(summary)
         counts = Core::Test::Result::TYPES.map { |status| [status, summary.total(status)] }
-        counts = counts.select { |_status, count| count > 0 }
+        counts = counts.select { |_status, count| count.positive? }
         counts = counts.map { |status, count| format_string("#{count} #{status}", status) }
         "(#{counts.join(', ')})" if counts.any?
       end

data/lib/cucumber/formatter/console_issues.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'cucumber/formatter/console'
 
 module Cucumber
@@ -12,9 +14,9 @@ module Cucumber
         @config.on_event(:test_case_finished) do |event|
           if event.test_case != @previous_test_case
             @previous_test_case = event.test_case
-            @issues[event.result.to_sym] << event.test_case unless event.result.ok?(@config.strict)
+            @issues[event.result.to_sym] << event.test_case unless event.result.ok?(strict: @config.strict)
           elsif event.result.passed?
-            @issues[:flaky] << event.test_case unless Core::Test::Result::Flaky.ok?(@config.strict.strict?(:flaky))
+            @issues[:flaky] << event.test_case unless Core::Test::Result::Flaky.ok?(strict: @config.strict.strict?(:flaky))
             @issues[:failed].delete(event.test_case)
           end
         end

data/lib/cucumber/formatter/curl_option_parser.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'shellwords'
+
+module Cucumber
+  module Formatter
+    class CurlOptionParser
+      def self.parse(options)
+        args = Shellwords.split(options)
+
+        url = nil
+        http_method = 'PUT'
+        headers = {}
+
+        until args.empty?
+          arg = args.shift
+          case arg
+          when '-X', '--request'
+            http_method = remove_arg_for(args, arg)
+          when '-H'
+            header_arg = remove_arg_for(args, arg)
+            headers = headers.merge(parse_header(header_arg))
+          else
+            raise StandardError, "#{options} was not a valid curl command. Can't set url to #{arg} it is already set to #{url}" if url
+
+            url = arg
+          end
+        end
+        raise StandardError, "#{options} was not a valid curl command" unless url
+
+        [url, http_method, headers]
+      end
+
+      # TODO: [LH] -> Switch below methods to private
+      def self.remove_arg_for(args, arg)
+        return args.shift unless args.empty?
+
+        raise StandardError, "Missing argument for #{arg}"
+      end
+
+      def self.parse_header(header_arg)
+        parts = header_arg.split(':', 2)
+        raise StandardError, "#{header_arg} was not a valid header" unless parts.length == 2
+
+        { parts[0].strip => parts[1].strip }
+      end
+    end
+  end
+end

data/lib/cucumber/formatter/errors.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Cucumber
   module Formatter
     class TestCaseUnknownError < StandardError; end

data/lib/cucumber/formatter/fail_fast.rb

@@ -12,7 +12,7 @@ module Cucumber
           test_case, result = *event.attributes
           if test_case != @previous_test_case
             @previous_test_case = event.test_case
-            Cucumber.wants_to_quit = true unless result.ok?(configuration.strict)
+            Cucumber.wants_to_quit = true unless result.ok?(strict: configuration.strict)
           elsif result.passed?
             Cucumber.wants_to_quit = false
           end

data/lib/cucumber/formatter/html.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'cucumber/formatter/io'
 require 'cucumber/html_formatter'
 require 'cucumber/formatter/message_builder'

data/lib/cucumber/formatter/http_io.rb

@@ -1,151 +1,19 @@
+# frozen_string_literal: true
+
 require 'net/http'
 require 'tempfile'
-require 'shellwords'
+require_relative 'curl_option_parser'
+require_relative 'io_http_buffer'
 
 module Cucumber
   module Formatter
     class HTTPIO
-      class << self
-        # Returns an IO that will write to a HTTP request's body
-        # https_verify_mode can be set to OpenSSL::SSL::VERIFY_NONE
-        # to ignore unsigned certificate - setting to nil will verify the certificate
-        def open(url, https_verify_mode = nil, reporter = nil)
-          @https_verify_mode = https_verify_mode
-          uri, method, headers = CurlOptionParser.parse(url)
-          IOHTTPBuffer.new(uri, method, headers, https_verify_mode, reporter)
-        end
-      end
-    end
-
-    class CurlOptionParser
-      def self.parse(options)
-        args = Shellwords.split(options)
-
-        url = nil
-        http_method = 'PUT'
-        headers = {}
-
-        until args.empty?
-          arg = args.shift
-          case arg
-          when '-X', '--request'
-            http_method = remove_arg_for(args, arg)
-          when '-H'
-            header_arg = remove_arg_for(args, arg)
-            headers = headers.merge(parse_header(header_arg))
-          else
-            raise StandardError, "#{options} was not a valid curl command. Can't set url to #{arg} it is already set to #{url}" if url
-
-            url = arg
-          end
-        end
-        raise StandardError, "#{options} was not a valid curl command" unless url
-
-        [
-          url,
-          http_method,
-          headers
-        ]
-      end
-
-      def self.remove_arg_for(args, arg)
-        return args.shift unless args.empty?
-
-        raise StandardError, "Missing argument for #{arg}"
-      end
-
-      def self.parse_header(header_arg)
-        parts = header_arg.split(':', 2)
-        raise StandardError, "#{header_arg} was not a valid header" unless parts.length == 2
-
-        { parts[0].strip => parts[1].strip }
-      end
-    end
-
-    class IOHTTPBuffer
-      attr_reader :uri, :method, :headers
-
-      def initialize(uri, method, headers = {}, https_verify_mode = nil, reporter = nil)
-        @uri = URI(uri)
-        @method = method
-        @headers = headers
-        @write_io = Tempfile.new('cucumber', encoding: 'UTF-8')
-        @https_verify_mode = https_verify_mode
-        @reporter = reporter || NoReporter.new
-      end
-
-      def close
-        response = send_content(@uri, @method, @headers)
-        @reporter.report(response.body)
-        @write_io.close
-        return if response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPRedirection)
-
-        raise StandardError, "request to #{uri} failed with status #{response.code}"
-      end
-
-      def write(data)
-        @write_io.write(data)
-      end
-
-      def flush
-        @write_io.flush
-      end
-
-      def closed?
-        @write_io.closed?
-      end
-
-      private
-
-      def send_content(uri, method, headers, attempt = 10)
-        content = (method == 'GET' ? StringIO.new : @write_io)
-        http = build_client(uri, @https_verify_mode)
-
-        raise StandardError, "request to #{uri} failed (too many redirections)" if attempt <= 0
-
-        req = build_request(
-          uri,
-          method,
-          headers.merge(
-            'Content-Length' => content.size.to_s
-          )
-        )
-
-        content.rewind
-        req.body_stream = content
-
-        begin
-          response = http.request(req)
-        rescue SystemCallError
-          # We may get the redirect response before pushing the file.
-          response = http.request(build_request(uri, method, headers))
-        end
-
-        case response
-        when Net::HTTPAccepted
-          send_content(URI(response['Location']), 'PUT', {}, attempt - 1) if response['Location']
-        when Net::HTTPRedirection
-          send_content(URI(response['Location']), method, headers, attempt - 1)
-        end
-        response
-      end
-
-      def build_request(uri, method, headers)
-        method_class_name = "#{method[0].upcase}#{method[1..].downcase}"
-        req = Net::HTTP.const_get(method_class_name).new(uri)
-        headers.each do |header, value|
-          req[header] = value
-        end
-        req
-      end
-
-      def build_client(uri, https_verify_mode)
-        http = Net::HTTP.new(uri.hostname, uri.port)
-        if uri.scheme == 'https'
-          http.use_ssl = true
-          http.verify_mode = https_verify_mode if https_verify_mode
-        end
-        http
+      # Returns an IO that will write to a HTTP request's body
+      # https_verify_mode can be set to OpenSSL::SSL::VERIFY_NONE
+      # to ignore unsigned certificate - setting to nil will verify the certificate
+      def self.open(url, https_verify_mode = nil, reporter = nil)
+        uri, method, headers = CurlOptionParser.parse(url)
+        IOHTTPBuffer.new(uri, method, headers, https_verify_mode, reporter)
       end
     end
   end

data/lib/cucumber/formatter/io_http_buffer.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Cucumber
+  module Formatter
+    class IOHTTPBuffer
+      attr_reader :uri, :method, :headers
+
+      def initialize(uri, method, headers = {}, https_verify_mode = nil, reporter = nil)
+        @uri = URI(uri)
+        @method = method
+        @headers = headers
+        @write_io = Tempfile.new('cucumber', encoding: 'UTF-8')
+        @https_verify_mode = https_verify_mode
+        @reporter = reporter || NoReporter.new
+      end
+
+      def close
+        @reporter.report(response.body)
+        @write_io.close
+        return if response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPRedirection)
+
+        raise StandardError, "request to #{uri} failed with status #{response.code}"
+      end
+
+      def write(data)
+        @write_io.write(data)
+      end
+
+      def flush
+        @write_io.flush
+      end
+
+      def closed?
+        @write_io.closed?
+      end
+
+      private
+
+      def response
+        @response ||= send_content(uri, method, headers)
+      end
+
+      def send_content(uri, method, headers, attempts_remaining = 10)
+        content = (method == 'GET' ? StringIO.new : @write_io)
+        http = build_client(uri)
+
+        raise StandardError, "request to #{uri} failed (too many redirections)" if attempts_remaining <= 0
+
+        request = build_request(uri, method, headers.merge('Content-Length' => content.size.to_s))
+        content.rewind
+        request.body_stream = content
+
+        begin
+          response = http.request(request)
+        rescue SystemCallError
+          # We may get the redirect response before pushing the file.
+          response = http.request(build_request(uri, method, headers))
+        end
+
+        case response
+        when Net::HTTPAccepted
+          send_content(URI(response['Location']), 'PUT', {}, attempts_remaining - 1) if response['Location']
+        when Net::HTTPRedirection
+          send_content(URI(response['Location']), method, headers, attempts_remaining - 1)
+        end
+        response
+      end
+
+      def build_request(uri, method, headers)
+        method_class_name = "#{method[0].upcase}#{method[1..].downcase}"
+        Net::HTTP.const_get(method_class_name).new(uri).tap do |request|
+          headers.each do |header, value|
+            request[header] = value
+          end
+        end
+      end
+
+      def build_client(uri)
+        Net::HTTP.new(uri.hostname, uri.port).tap do |http|
+          if uri.scheme == 'https'
+            http.use_ssl = true
+            http.verify_mode = @https_verify_mode if @https_verify_mode
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/formatter/json.rb

@@ -85,7 +85,7 @@ module Cucumber
         @io.write(JSON.pretty_generate(@feature_hashes))
       end
 
-      def attach(src, mime_type)
+      def attach(src, mime_type, _filename)
         if mime_type == 'text/x.cucumber.log+plain'
           test_step_output << src
           return
@@ -102,7 +102,7 @@ module Cucumber
       private
 
       def same_feature_as_previous_test_case?(test_case)
-        current_feature[:uri] == test_case.location.file
+        @feature_hash&.fetch(:uri, nil) == test_case.location.file
       end
 
       def first_step_after_background?(test_step)
@@ -113,10 +113,6 @@ module Cucumber
         test_step.location.file.include?('lib/cucumber/')
       end
 
-      def current_feature
-        @feature_hash ||= {} # rubocop:disable Naming/MemoizedInstanceVariableName
-      end
-
       def feature_elements
         @feature_hash[:elements] ||= []
       end

data/lib/cucumber/formatter/junit.rb

@@ -54,7 +54,7 @@ module Cucumber
         test_step, result = *event.attributes
         return if @failing_test_step
 
-        @failing_test_step = test_step unless result.ok?(@config.strict)
+        @failing_test_step = test_step unless result.ok?(strict: @config.strict)
       end
 
       def on_test_case_finished(event)
@@ -71,7 +71,7 @@ module Cucumber
       end
 
       def on_test_run_finished(_event)
-        @features_data.each { |_file, data| end_feature(data) }
+        @features_data.each_value { |data| end_feature(data) }
       end
 
       private
@@ -111,7 +111,7 @@ module Cucumber
         scenario_source = @ast_lookup.scenario_source(test_case)
         keyword = scenario_source.type == :Scenario ? scenario_source.scenario.keyword : scenario_source.scenario_outline.keyword
         output = "#{keyword}: #{scenario}\n\n"
-        return output if result.ok?(@config.strict)
+        return output if result.ok?(strict: @config.strict)
 
         if scenario_source.type == :Scenario
           if @failing_test_step
@@ -140,7 +140,7 @@ module Cucumber
         testcase_attributes = get_testcase_attributes(classname, name, duration, filename)
 
         @current_feature_data[:builder].testcase(testcase_attributes) do
-          if !result.passed? && result.ok?(@config.strict)
+          if !result.passed? && result.ok?(strict: @config.strict)
             @current_feature_data[:builder].skipped
             @current_feature_data[:skipped] += 1
           elsif !result.passed?

data/lib/cucumber/formatter/message_builder.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'base64'
 require 'cucumber/formatter/backtrace_filter'
 require 'cucumber/formatter/query/hook_by_test_step'
@@ -40,11 +42,12 @@ module Cucumber
         raise 'To be implemented'
       end
 
-      def attach(src, media_type)
+      def attach(src, media_type, filename)
         attachment_data = {
           test_step_id: @current_test_step_id,
           test_case_started_id: @current_test_case_started_id,
-          media_type: media_type
+          media_type: media_type,
+          file_name: filename
         }
 
         if media_type.start_with?('text/')
@@ -129,7 +132,7 @@ module Cucumber
         @step_definitions_by_test_step.step_match_arguments(step).map do |argument|
           Cucumber::Messages::StepMatchArgument.new(
             group: argument_group_to_message(argument.group),
-            parameter_type_name: argument.parameter_type.name
+            parameter_type_name: parameter_type_name(argument)
           )
         end
       end
@@ -142,6 +145,10 @@ module Cucumber
         )
       end
 
+      def parameter_type_name(step_match_argument)
+        step_match_argument.parameter_type&.name if step_match_argument.respond_to?(:parameter_type)
+      end
+
       def on_test_run_started(*)
         message = Cucumber::Messages::Envelope.new(
           test_run_started: Cucumber::Messages::TestRunStarted.new(
@@ -190,10 +197,13 @@ module Cucumber
 
         result_message = result.to_message
         if result.failed? || result.pending?
+          message_element = result.failed? ? result.exception : result
+
           result_message = Cucumber::Messages::TestStepResult.new(
             status: result_message.status,
             duration: result_message.duration,
-            message: create_error_message(result)
+            message: create_error_message(message_element),
+            exception: create_exception_object(result, message_element)
           )
         end
 
@@ -209,12 +219,17 @@ module Cucumber
         output_envelope(message)
       end
 
-      def create_error_message(result)
-        message_element = result.failed? ? result.exception : result
+      def create_error_message(message_element)
         message = "#{message_element.message} (#{message_element.class})"
         ([message] + message_element.backtrace).join("\n")
       end
 
+      def create_exception_object(result, message_element)
+        return unless result.failed?
+
+        Cucumber::Messages::Exception.from_h({ type: message_element.class, message: message_element.message })
+      end
+
       def on_test_case_finished(event)
         message = Cucumber::Messages::Envelope.new(
           test_case_finished: Cucumber::Messages::TestCaseFinished.new(